@zenky/storefront-vue 0.9.32

package/dist/cjs/index.js

@@ -0,0 +1,1913 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var lodashEs = require('lodash-es');
+var api = require('@zenky/api');
+var pinia = require('pinia');
+var ui = require('@zenky/ui');
+var events = require('@zenky/events');
+
+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);
+        }
+        finally {
+            destroying.value = false;
+        }
+        return false;
+    };
+    return {
+        destroying,
+        destroy,
+    };
+}
+
+function getApiErrorHandler(providedHandler, defaultHandler) {
+    return providedHandler ? providedHandler : defaultHandler;
+}
+
+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";
+})(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);
+        }
+        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);
+        }
+        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);
+        }
+        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);
+        }
+        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 } = 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) {
+            return;
+        }
+        try {
+            loading.value = true;
+            const { suggestions } = await api.getAddressSuggestions({
+                query: query.value,
+                city_id: cityId,
+            });
+            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,
+});
+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('Нужно выбрать улицу из выпадающего списка.');
+        }
+    }
+    else if (resolver === 'plain') {
+        if (!form.city) {
+            errors.push('Нужно указать город.');
+        }
+        else if (!form.street) {
+            errors.push('Нужно указать улицу.');
+        }
+        else if (!form.house) {
+            errors.push('Нужно указать номер дома.');
+        }
+        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: '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: '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, function (e) {
+        ui.useNotification('error', 'Ошибка', api.getApiErrorMessage(e, 'Не удалось загрузить список фильтров.'));
+    }));
+}
+function useCategoryFeaturesGroupsList(categoryId, errorHandler) {
+    return useListLoader(async function () {
+        if (!categoryId) {
+            return [];
+        }
+        return api.getCategoryFeaturesGroups(categoryId);
+    }, getApiErrorHandler(errorHandler, function (e) {
+        ui.useNotification('error', 'Ошибка', api.getApiErrorMessage(e, 'Не удалось загрузить список фильтров.'));
+    }));
+}
+
+function useArticlesList(errorHandler) {
+    return usePaginatedLoader(api.getArticles, getApiErrorHandler(errorHandler, function (e) {
+        ui.useNotification('error', 'Ошибка', api.getApiErrorMessage(e, 'Не удалось загрузить список статей.'));
+    }));
+}
+function useArticleCategoriesList(errorHandler) {
+    return usePaginatedLoader(api.getArticleCategories, getApiErrorHandler(errorHandler, function (e) {
+        ui.useNotification('error', 'Ошибка', api.getApiErrorMessage(e, 'Не удалось загрузить список категорий статей.'));
+    }));
+}
+function useArticleItem(errorHandler) {
+    return useItemLoader(api.getArticle, getApiErrorHandler(errorHandler, function (e) {
+        ui.useNotification('error', 'Ошибка', api.getApiErrorMessage(e, 'Не удалось загрузить статью.'));
+    }));
+}
+
+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["Pending"] = "pending";
+    AuthenticationResultType["Validation"] = "validation";
+    AuthenticationResultType["Failed"] = "failed";
+    AuthenticationResultType["Completed"] = "completed";
+    AuthenticationResultType["Stage"] = "stage";
+})(exports.AuthenticationResultType || (exports.AuthenticationResultType = {}));
+
+function useAuthenticationStatusChecker(form, emit) {
+    const active = vue.ref(false);
+    const check = async () => {
+        if (active.value) {
+            return {
+                type: exports.AuthenticationResultType.Pending,
+            };
+        }
+        else if (!form.value.phone.number || !form.value.phone.country) {
+            ui.useNotification('error', 'Ошибка', 'Нужно указать номер телефона.');
+            return {
+                type: exports.AuthenticationResultType.Validation,
+                data: 'phone',
+            };
+        }
+        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.Completed,
+                    data: exports.AuthenticationStage.Register,
+                };
+            }
+            else if (!status.confirmed) {
+                emit(exports.AuthenticationEvent.Stage, exports.AuthenticationStage.Confirmation);
+                return {
+                    type: exports.AuthenticationResultType.Completed,
+                    data: exports.AuthenticationStage.Confirmation,
+                };
+            }
+            emit(exports.AuthenticationEvent.Stage, exports.AuthenticationStage.Login);
+            return {
+                type: exports.AuthenticationResultType.Completed,
+                data: exports.AuthenticationStage.Login,
+            };
+        }
+        catch (e) {
+            ui.useNotification('error', 'Ошибка', api.getApiErrorMessage(e, 'Не удалось проверить статус регистрации. Повторите попытку.'));
+        }
+        finally {
+            active.value = false;
+        }
+        return {
+            type: exports.AuthenticationResultType.Failed,
+        };
+    };
+    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.Pending,
+            };
+        }
+        else if (!form.value.phone.number || !form.value.phone.country) {
+            ui.useNotification('error', 'Ошибка', 'Нужно указать номер телефона.');
+            return {
+                type: exports.AuthenticationResultType.Validation,
+                data: 'phone',
+            };
+        }
+        else if (!form.value.password) {
+            ui.useNotification('error', 'Ошибка', 'Нужно указать пароль.');
+            return {
+                type: exports.AuthenticationResultType.Validation,
+                data: 'password',
+            };
+        }
+        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);
+            ui.useNotification('success', 'Успешный вход', 'Вы успешно вошли в ваш аккаунт!');
+            emit(exports.AuthenticationEvent.Completed);
+            return {
+                type: exports.AuthenticationResultType.Completed,
+                data: customer,
+            };
+        }
+        catch (e) {
+            ui.useNotification('error', 'Ошибка', api.getApiErrorMessage(e, 'Указан неправильный пароль.'));
+        }
+        finally {
+            active.value = false;
+        }
+        return {
+            type: exports.AuthenticationResultType.Failed,
+        };
+    };
+    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.Pending,
+            };
+        }
+        else if (seconds.value > 0) {
+            ui.useNotification('error', 'Ошибка', 'Нужно подождать перед повторной отправкой кода сброса пароля.');
+            return {
+                type: exports.AuthenticationResultType.Pending,
+            };
+        }
+        else if (!form.value.phone.number || !form.value.phone.country) {
+            ui.useNotification('error', 'Ошибка', 'Нужно указать номер телефона.');
+            return {
+                type: exports.AuthenticationResultType.Validation,
+                data: 'phone',
+            };
+        }
+        active.value = true;
+        try {
+            await api.requestPasswordResetCode(form.value.phone);
+            ui.useNotification('success', 'Код отправлен', 'Код сброса пароля был отправлен на ваш номер.');
+            sent.value = true;
+            start();
+            return {
+                type: exports.AuthenticationResultType.Completed,
+            };
+        }
+        catch (e) {
+            ui.useNotification('error', 'Ошибка', api.getApiErrorMessage(e, 'Нужно подождать перед повторной отправкой кода сброса пароля.'));
+        }
+        finally {
+            active.value = false;
+        }
+        return {
+            type: exports.AuthenticationResultType.Failed,
+        };
+    };
+    return {
+        seconds,
+        label,
+        request,
+        sent,
+    };
+}
+function useReset(form, active, emit) {
+    const reset = async () => {
+        if (active.value) {
+            return {
+                type: exports.AuthenticationResultType.Pending,
+            };
+        }
+        else if (!form.value.phone.number || !form.value.phone.country) {
+            ui.useNotification('error', 'Ошибка', 'Нужно указать номер телефона.');
+            return {
+                type: exports.AuthenticationResultType.Validation,
+                data: 'phone',
+            };
+        }
+        else if (!form.value.password) {
+            ui.useNotification('error', 'Ошибка', 'Нужно придумать новый пароль.');
+            return {
+                type: exports.AuthenticationResultType.Validation,
+                data: 'password',
+            };
+        }
+        else if (!form.value.confirmation_code) {
+            ui.useNotification('error', 'Ошибка', 'Нужно указать код из SMS.');
+            return {
+                type: exports.AuthenticationResultType.Validation,
+                data: 'confirmation_code',
+            };
+        }
+        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);
+            ui.useNotification('success', 'Пароль изменён', 'Вы успешно изменили пароль и вошли в свой аккаунт.');
+            emit(exports.AuthenticationEvent.Completed);
+            return {
+                type: exports.AuthenticationResultType.Completed,
+                data: result.customer,
+            };
+        }
+        catch (e) {
+            ui.useNotification('error', 'Ошибка', api.getApiErrorMessage(e, 'Указан неправильный код сброса пароля.'));
+        }
+        finally {
+            active.value = false;
+        }
+        return {
+            type: exports.AuthenticationResultType.Failed,
+        };
+    };
+    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.Pending,
+            };
+        }
+        else if (!form.value.phone.number || !form.value.phone.country) {
+            ui.useNotification('error', 'Ошибка', 'Нужно указать номер телефона.');
+            return {
+                type: exports.AuthenticationResultType.Validation,
+                data: 'phone',
+            };
+        }
+        else if (!form.value.password) {
+            ui.useNotification('error', 'Ошибка', 'Нужно придумать пароль.');
+            return {
+                type: exports.AuthenticationResultType.Validation,
+                data: 'password',
+            };
+        }
+        active.value = true;
+        try {
+            const result = await api.register(form.value.phone, form.value.password);
+            if (!result.confirmation_required) {
+                emit(exports.AuthenticationEvent.Completed);
+                ui.useNotification('success', 'Успешная регистрация', 'Вы успешно зарегистрировались!');
+                return {
+                    type: exports.AuthenticationResultType.Completed,
+                };
+            }
+            emit(exports.AuthenticationEvent.Stage, exports.AuthenticationStage.Confirmation);
+            return {
+                type: exports.AuthenticationResultType.Stage,
+                data: exports.AuthenticationStage.Confirmation,
+            };
+        }
+        catch (e) {
+            ui.useNotification('error', 'Ошибка', api.getApiErrorMessage(e, 'Этот телефон уже зарегистрирован.'));
+        }
+        finally {
+            active.value = false;
+        }
+        return {
+            type: exports.AuthenticationResultType.Failed,
+        };
+    };
+    return {
+        active,
+        register,
+    };
+}
+
+function useResend(form, active) {
+    const { seconds, label, start } = useTimer(60);
+    const resend = async () => {
+        if (active.value) {
+            return {
+                type: exports.AuthenticationResultType.Pending,
+            };
+        }
+        else if (seconds.value > 0) {
+            ui.useNotification('error', 'Ошибка', 'Нужно подождать перед повторной отправкой кода подтверждения.');
+            return {
+                type: exports.AuthenticationResultType.Pending,
+            };
+        }
+        else if (!form.value.phone.number || !form.value.phone.country) {
+            ui.useNotification('error', 'Ошибка', 'Нужно указать номер телефона.');
+            return {
+                type: exports.AuthenticationResultType.Validation,
+                data: 'phone',
+            };
+        }
+        active.value = true;
+        try {
+            await api.resendConfirmationCode(form.value.phone);
+            start();
+            return {
+                type: exports.AuthenticationResultType.Completed,
+            };
+        }
+        catch (e) {
+            ui.useNotification('error', 'Ошибка', api.getApiErrorMessage(e, 'Нужно подождать перед повторной отправкой кода подтверждения.'));
+        }
+        finally {
+            active.value = false;
+        }
+        return {
+            type: exports.AuthenticationResultType.Failed,
+        };
+    };
+    return {
+        seconds,
+        label,
+        start,
+        resend,
+    };
+}
+function useConfirm(form, active, emit) {
+    const confirm = async (withPassword = false) => {
+        if (active.value) {
+            return {
+                type: exports.AuthenticationResultType.Pending,
+            };
+        }
+        else if (!form.value.phone.number || !form.value.phone.country) {
+            ui.useNotification('error', 'Ошибка', 'Нужно указать номер телефона.');
+            return {
+                type: exports.AuthenticationResultType.Validation,
+                data: 'phone',
+            };
+        }
+        else if (!form.value.confirmation_code) {
+            ui.useNotification('error', 'Ошибка', 'Нужно указать код из SMS.');
+            return {
+                type: exports.AuthenticationResultType.Validation,
+                data: 'confirmation_code',
+            };
+        }
+        else if (withPassword && !form.value.password) {
+            ui.useNotification('error', 'Ошибка', 'Нужно указать новый пароль.');
+            return {
+                type: exports.AuthenticationResultType.Validation,
+                data: 'password',
+            };
+        }
+        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);
+            ui.useNotification('success', 'Успешное подтверждение телефона', 'Вы успешно подтвердили телефон и вошли в свой аккаунт.');
+            emit(exports.AuthenticationEvent.Completed);
+            return {
+                type: exports.AuthenticationResultType.Completed,
+                data: result.customer,
+            };
+        }
+        catch (e) {
+            ui.useNotification('error', 'Ошибка', api.getApiErrorMessage(e, 'Указан неправильный код подтверждения.'));
+            if (api.getApiErrorCode(e) === 'auth.registration.password_required') {
+                return {
+                    type: exports.AuthenticationResultType.Validation,
+                    data: 'password',
+                };
+            }
+        }
+        finally {
+            active.value = false;
+        }
+        return {
+            type: exports.AuthenticationResultType.Failed,
+        };
+    };
+    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, function (e) {
+        ui.useNotification('error', 'Ошибка', api.getApiErrorMessage(e, 'Не удалось загрузить адреса доставки.'));
+    }));
+}
+function useDeliveryAddressDestroyer(errorHandler) {
+    return useDataDestroyer(api.deleteAddress, getApiErrorHandler(errorHandler, function (e) {
+        ui.useNotification('error', 'Ошибка', api.getApiErrorMessage(e, 'Не удалось удалить адрес доставки.'));
+    }));
+}
+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 false;
+        }
+        const { errors, data } = useAddressFormValue(form.value, address.resolver, address);
+        if (errors.length > 0) {
+            ui.useNotification('error', 'Ошибка', errors[0]);
+            return false;
+        }
+        saving.value = true;
+        try {
+            await api.updateAddress(address.id, {
+                delivery_address: {
+                    ...data,
+                    name: form.value.name,
+                },
+            });
+            ui.useNotification('success', 'Адрес сохранён', 'Адрес был успешно сохранён!');
+            return true;
+        }
+        catch (e) {
+            ui.useNotification('error', 'Ошибка', api.getApiErrorMessage(e, 'Не удалось сохранить адрес. Повторите попытку.'));
+        }
+        finally {
+            saving.value = false;
+        }
+        return 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, function (e) {
+        ui.useNotification('error', 'Ошибка', api.getApiErrorMessage(e, 'Не удалось загрузить список заказов.'));
+    }));
+}
+function useOrderItem(errorHandler) {
+    return useItemLoader(api.getOrder, getApiErrorHandler(errorHandler, function (e) {
+        ui.useNotification('error', 'Ошибка', api.getApiErrorMessage(e, 'Заказ не найден.'));
+    }));
+}
+
+function usePaymentMethodsList(errorHandler) {
+    return usePaginatedLoader(api.getCustomerPaymentMethods, getApiErrorHandler(errorHandler, function (e) {
+        ui.useNotification('error', 'Ошибка', api.getApiErrorMessage(e, 'Не удалось загрузить способы оплаты.'));
+    }));
+}
+function usePaymentMethodDestroyer(errorHandler) {
+    return useDataDestroyer(api.deleteCustomerPaymentMethod, getApiErrorHandler(errorHandler, function (e) {
+        ui.useNotification('error', 'Ошибка', api.getApiErrorMessage(e, 'Не удалось удалить способ оплаты.'));
+    }));
+}
+
+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 useProductsPricesRange(categoryId, errorHandler) {
+    return useDataLoader(async () => api.getProductsPricesRange(categoryId), getApiErrorHandler(errorHandler, function (e) {
+        ui.useNotification('error', 'Ошибка', api.getApiErrorMessage(e, 'Не удалось загрузить диапазон цен.'));
+    }));
+}
+
+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,
+    };
+}
+
+var ProductsSourceType;
+(function (ProductsSourceType) {
+    ProductsSourceType["Category"] = "category";
+    ProductsSourceType["Collection"] = "collection";
+})(ProductsSourceType || (ProductsSourceType = {}));
+var ProductsSorting;
+(function (ProductsSorting) {
+    ProductsSorting["Manual"] = "manual";
+    ProductsSorting["NameAsc"] = "name";
+    ProductsSorting["NameDesc"] = "-name";
+    ProductsSorting["PriceAsc"] = "price";
+    ProductsSorting["PriceDesc"] = "-price";
+})(ProductsSorting || (ProductsSorting = {}));
+var ProductsFiltersType;
+(function (ProductsFiltersType) {
+    ProductsFiltersType["Features"] = "features";
+    ProductsFiltersType["FeaturesGroups"] = "featuresGroups";
+})(ProductsFiltersType || (ProductsFiltersType = {}));
+
+function getSourceParams(source) {
+    if (source === null || !source.id || !source.type) {
+        return {};
+    }
+    switch (source.type) {
+        case 'category':
+            return { category_id: source.id };
+        case 'collection':
+            return { collection_id: source.id };
+        default:
+            return {};
+    }
+}
+function getSortingParams(sorting) {
+    if (!sorting) {
+        return {};
+    }
+    switch (sorting) {
+        case ProductsSorting.Manual:
+        case ProductsSorting.NameAsc:
+        case ProductsSorting.NameDesc:
+        case ProductsSorting.PriceAsc:
+        case 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;
+    }
+    return params;
+}
+function getProductsPaginationRequest(page, loader) {
+    if (loader.source && typeof loader.source.error !== 'undefined' && loader.source.error) {
+        return null;
+    }
+    return {
+        ...getSourceParams(loader.source),
+        ...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 !== ProductsSourceType.Category) {
+        return null;
+    }
+    return source.id;
+}
+function useProductsList(config, errorHandler) {
+    const productsLoader = usePaginatedLoader(api.getProducts, getApiErrorHandler(errorHandler, function (e) {
+        ui.useNotification('error', 'Ошибка', api.getApiErrorMessage(e, 'Не удалось загрузить товары.'));
+    }));
+    const store = useStoreStore();
+    const cityId = vue.computed(() => store.cityId);
+    const sorting = vue.ref(config.value.sorting || ProductsSorting.Manual);
+    const search = vue.ref(config.value.search || '');
+    const { filters, load: loadFilters, items: features, } = config.value.filtersType === 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 || '',
+    }));
+    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 getProductsListQueryParams(config, request) {
+    if (request === null) {
+        return {};
+    }
+    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 query;
+}
+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: typeof query.min_price !== 'undefined' && query.min_price ? query.min_price : null,
+        max_price: typeof query.max_price !== 'undefined' && query.max_price ? query.max_price : null,
+        search: typeof query.search !== 'undefined' && query.search ? query.search : null,
+    };
+}
+
+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 ProductsSourceType.Category:
+            return getInjectedSource(exports.ZenkyInjection.Category, exports.ZenkyInjection.CategoryNotFound, injected);
+        case ProductsSourceType.Collection:
+            return getInjectedSource(exports.ZenkyInjection.Collection, exports.ZenkyInjection.CollectionNotFound, injected);
+        default:
+            return null;
+    }
+}
+
+exports.createStorage = createStorage;
+exports.getAddressForm = getAddressForm;
+exports.getApiErrorHandler = getApiErrorHandler;
+exports.getExistedAddress = getExistedAddress;
+exports.getExistedAddressDisplayValue = getExistedAddressDisplayValue;
+exports.getFirstMedium = getFirstMedium;
+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.useAddressFormValue = useAddressFormValue;
+exports.useArticleCategoriesList = useArticleCategoriesList;
+exports.useArticleItem = useArticleItem;
+exports.useArticlesList = useArticlesList;
+exports.useAuthenticationForm = useAuthenticationForm;
+exports.useAuthenticationStatusChecker = useAuthenticationStatusChecker;
+exports.useCategories = useCategories;
+exports.useCategoriesStore = useCategoriesStore;
+exports.useCategoriesTree = useCategoriesTree;
+exports.useCategory = useCategory;
+exports.useCategoryFeaturesGroupsList = useCategoryFeaturesGroupsList;
+exports.useCategoryFeaturesList = useCategoryFeaturesList;
+exports.useCollection = useCollection;
+exports.useCollections = useCollections;
+exports.useCollectionsStore = useCollectionsStore;
+exports.useCustomer = useCustomer;
+exports.useCustomerStore = useCustomerStore;
+exports.useDadata = useDadata;
+exports.useDataDestroyer = useDataDestroyer;
+exports.useDataLoader = useDataLoader;
+exports.useDeliveryAddressDestroyer = useDeliveryAddressDestroyer;
+exports.useDeliveryAddressesList = useDeliveryAddressesList;
+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.useOrderItem = useOrderItem;
+exports.useOrdersList = useOrdersList;
+exports.usePaginatedLoader = usePaginatedLoader;
+exports.usePasswordReset = usePasswordReset;
+exports.usePaymentMethodDestroyer = usePaymentMethodDestroyer;
+exports.usePaymentMethodsList = usePaymentMethodsList;
+exports.usePhoneConfirmation = usePhoneConfirmation;
+exports.useProductsList = useProductsList;
+exports.useProductsPricesRange = useProductsPricesRange;
+exports.useProductsPricesRangeFilters = useProductsPricesRangeFilters;
+exports.useRegistration = useRegistration;
+exports.useReversedTree = useReversedTree;
+exports.useSplittedCategoriesTree = useSplittedCategoriesTree;
+exports.useStateDataLoader = useStateDataLoader;
+exports.useStoreStore = useStoreStore;
+exports.useSuggestionsRestrictedToCity = useSuggestionsRestrictedToCity;