@zenky/storefront-vue 0.9.39 → 0.9.40

package/dist/cjs/index.js

@@ -2521,6 +2521,388 @@ function useCheckoutTotal() {
     };
 }
 
+function useSingleModifier(props, emit) {
+    const value = vue.computed({
+        get: () => props.modelValue,
+        set: (val) => emit('update:modelValue', val),
+    });
+    const checked = vue.computed({
+        get: () => value.value.quantity > 0,
+        set: (val) => {
+            value.value.quantity = val ? 1 : 0;
+        },
+    });
+    const shouldUseQuantityControls = vue.computed(() => props.modifier.max_quantity > 1);
+    const increase = () => {
+        if (props.limitReached) {
+            return;
+        }
+        value.value.quantity = Math.min(value.value.quantity + 1, props.modifier.max_quantity);
+    };
+    const decrease = () => {
+        value.value.quantity = Math.max(value.value.quantity - 1, props.modifier.min_quantity);
+    };
+    return {
+        value,
+        checked,
+        shouldUseQuantityControls,
+        increase,
+        decrease,
+    };
+}
+
+function getModifierQuantity(modifier, value) {
+    const index = value.value.findIndex((item) => item.modifier_id === modifier.modifier.id);
+    if (index === -1) {
+        return 0;
+    }
+    return value.value[index].quantity;
+}
+function getDefaultModifiersGroupModifiers(group, value) {
+    const modifiers = {};
+    group.modifiers.forEach((modifier) => {
+        const quantity = Array.isArray(value.value) ? getModifierQuantity(modifier, value) : 0;
+        modifiers[modifier.modifier.id] = {
+            quantity,
+            modifier_id: modifier.modifier.id,
+        };
+    });
+    return modifiers;
+}
+function getSelectedModifiers$1(group, modifiers) {
+    const selected = [];
+    Object.keys(modifiers).forEach((modifierId) => {
+        if (!modifiers[modifierId].quantity) {
+            return;
+        }
+        selected.push({
+            modifiers_group_id: group.group.id,
+            modifier_id: modifierId,
+            quantity: modifiers[modifierId].quantity,
+        });
+    });
+    return selected;
+}
+function useModifiersGroup(props, emit) {
+    const value = vue.computed({
+        get: () => props.modelValue,
+        set: (val) => emit('update:modelValue', val),
+    });
+    const selectedModifier = vue.ref('');
+    const modifiers = vue.ref(getDefaultModifiersGroupModifiers(props.group, value));
+    const shouldUseQuantityControls = vue.computed(() => props.group.max_quantity > 1);
+    const totalSelectedCount = vue.computed(() => {
+        return value.value
+            .map((modifier) => modifier.quantity)
+            .reduce((current, total) => current + total, 0);
+    });
+    const limitReached = vue.computed(() => {
+        if (!shouldUseQuantityControls.value) {
+            return selectedModifier.value !== '';
+        }
+        return totalSelectedCount.value >= props.group.max_quantity;
+    });
+    const requiredModifierIsMissing = vue.computed(() => {
+        if (!props.group.is_required) {
+            return false;
+        }
+        else if (props.group.min_quantity === 0) {
+            return false;
+        }
+        return totalSelectedCount.value < props.group.min_quantity;
+    });
+    vue.watch(selectedModifier, (val) => {
+        if (!val) {
+            value.value = [];
+            return;
+        }
+        value.value = [{
+                modifiers_group_id: props.group.group.id,
+                modifier_id: val,
+                quantity: 1,
+            }];
+    });
+    vue.watch(modifiers, (val) => {
+        value.value = getSelectedModifiers$1(props.group, val);
+    }, { deep: true });
+    return {
+        selectedModifier,
+        modifiers,
+        shouldUseQuantityControls,
+        requiredModifierIsMissing,
+        limitReached,
+    };
+}
+
+function getModifiers(product, variant) {
+    const modifiers = {};
+    ((product === null || product === void 0 ? void 0 : product.modifiers) || []).forEach((modifier) => {
+        modifiers[modifier.modifier.id] = {
+            modifier_id: modifier.modifier.id,
+            quantity: 0,
+        };
+    });
+    ((product === null || product === void 0 ? void 0 : product.modifiers_groups) || []).forEach((group) => {
+        modifiers[group.group.id] = [];
+    });
+    if (!variant.value || !variant.value.selected_modifiers || !variant.value.selected_modifiers.modifiers) {
+        return modifiers;
+    }
+    else if (!variant.value.selected_modifiers.modifiers.length) {
+        return modifiers;
+    }
+    variant.value.selected_modifiers.modifiers.forEach((modifier) => {
+        if (typeof modifier.modifiers_group_id !== 'undefined' && modifier.modifiers_group_id) {
+            modifiers[modifier.modifiers_group_id].push(modifier);
+        }
+        else if (typeof modifier.modifier_id !== 'undefined' && modifier.modifier_id) {
+            modifiers[modifier.modifier_id] = {
+                modifier_id: modifier.modifier_id,
+                quantity: modifier.quantity,
+            };
+        }
+    });
+    return modifiers;
+}
+function getSelectedModifiers(modifiers) {
+    const selected = [];
+    Object.keys(modifiers.value).forEach((modifierId) => {
+        const isGroup = Array.isArray(modifiers.value[modifierId]);
+        if (!isGroup && !modifiers.value[modifierId].quantity) {
+            return;
+        }
+        else if (!isGroup) {
+            selected.push({
+                modifier_id: modifierId,
+                quantity: modifiers.value[modifierId].quantity,
+            });
+            return;
+        }
+        modifiers.value[modifierId].forEach((modifier) => {
+            if (!modifier.modifier_id || !modifier.quantity || !modifier.modifiers_group_id) {
+                return;
+            }
+            selected.push({
+                modifiers_group_id: modifier.modifiers_group_id,
+                modifier_id: modifier.modifier_id,
+                quantity: modifier.quantity,
+            });
+        });
+    });
+    return selected;
+}
+function useModifiers(product, variant, recalculate) {
+    var _a, _b;
+    const modifiersHash = vue.ref(((_b = (_a = variant.value) === null || _a === void 0 ? void 0 : _a.selected_modifiers) === null || _b === void 0 ? void 0 : _b.hash) || null);
+    const modifiers = vue.ref(getModifiers(product, variant));
+    const selectedModifiers = vue.computed(() => getSelectedModifiers(modifiers));
+    vue.watch(variant, () => {
+        modifiers.value = getModifiers(product, variant);
+    });
+    vue.watch(selectedModifiers, async () => {
+        const hash = await recalculate(selectedModifiers);
+        if (hash === null) {
+            return;
+        }
+        modifiersHash.value = hash;
+    });
+    return {
+        modifiers,
+        selectedModifiers,
+        modifiersHash,
+    };
+}
+
+async function recalculatePrice(variant, modifiers) {
+    if (!variant.value) {
+        return null;
+    }
+    else if (!modifiers.value.length) {
+        return null;
+    }
+    const { cityId } = pinia.storeToRefs(useStoreStore());
+    try {
+        return await api.getProductVariantPrice(variant.value.product_id, variant.value.id, modifiers.value, {
+            city_id: cityId.value || undefined,
+        });
+    }
+    catch (e) {
+        //
+    }
+    return null;
+}
+function getProductVariantsPricesRange(variants) {
+    if (!variants.length) {
+        return null;
+    }
+    const sorted = [...variants].sort((first, second) => Math.sign(first.price.value - second.price.value));
+    return {
+        min: sorted[0].price,
+        max: sorted[sorted.length - 1].price,
+    };
+}
+function useVariantPrice(variants, variant) {
+    const result = vue.ref(null);
+    const recalculating = vue.ref(false);
+    const totalPrice = vue.computed(() => {
+        if (result.value !== null) {
+            return {
+                recalculated: true,
+                recalculating: recalculating.value,
+                price: result.value.price,
+                original_price: result.value.original_price,
+                has_discount: result.value.has_discount,
+                discount_id: result.value.discount_id,
+                discount_difference: result.value.discount_difference,
+                discount_percentage: result.value.discount_percentage,
+            };
+        }
+        else if (!variant.value) {
+            return null;
+        }
+        return {
+            recalculated: false,
+            recalculating: recalculating.value,
+            price: variant.value.price,
+            original_price: variant.value.original_price,
+            has_discount: variant.value.has_discount,
+            discount_id: variant.value.discount_id,
+            discount_difference: variant.value.discount_difference,
+            discount_percentage: variant.value.discount_percentage,
+        };
+    });
+    const pricesRange = vue.computed(() => getProductVariantsPricesRange(variants));
+    const recalculate = async (modifiers) => {
+        if (recalculating.value) {
+            return null;
+        }
+        recalculating.value = true;
+        result.value = await recalculatePrice(variant, modifiers);
+        recalculating.value = false;
+        return result.value !== null ? result.value.modifiers_hash : null;
+    };
+    return {
+        totalPrice,
+        pricesRange,
+        recalculating,
+        recalculate,
+    };
+}
+
+function getOptionsList(variants) {
+    const options = [];
+    if (variants.length <= 1) {
+        return options;
+    }
+    variants.forEach((variant) => {
+        if (!variant.option_values || !variant.option_values.length) {
+            return;
+        }
+        variant.option_values.forEach((optionValue) => {
+            if (!optionValue.option || !optionValue.option.id) {
+                return;
+            }
+            const optionIndex = options.findIndex((option) => { var _a; return option.id === ((_a = optionValue.option) === null || _a === void 0 ? void 0 : _a.id); });
+            if (optionIndex === -1) {
+                options.push({
+                    id: optionValue.option.id,
+                    name: optionValue.option.name,
+                    type: optionValue.option.type,
+                    values: [optionValue],
+                });
+                return;
+            }
+            const valueIndex = options[optionIndex].values.findIndex((item) => item.id === optionValue.id);
+            if (valueIndex !== -1) {
+                return;
+            }
+            options[optionIndex].values.push(optionValue);
+        });
+    });
+    return options;
+}
+function useVariant(variants) {
+    const options = vue.ref(getOptionsList(variants));
+    const selectedOptions = vue.ref({});
+    options.value.forEach((option) => {
+        selectedOptions.value[option.id] = option.values.length > 0 ? option.values[0].id : null;
+    });
+    const variant = vue.computed(() => {
+        if (!Array.isArray(variants) || !variants.length) {
+            return null;
+        }
+        else if (variants.length === 1) {
+            return variants[0];
+        }
+        else if (!Object.keys(selectedOptions.value).length) {
+            return variants[0];
+        }
+        const variantIndex = variants.findIndex((item) => {
+            if (!item.option_values || !item.option_values.length) {
+                return false;
+            }
+            return item.option_values.every((optionValue) => {
+                if (!optionValue.option || !optionValue.option.id) {
+                    return false;
+                }
+                else if (typeof selectedOptions.value[optionValue.option.id] === 'undefined') {
+                    return false;
+                }
+                else if (selectedOptions.value[optionValue.option.id] !== optionValue.id) {
+                    return false;
+                }
+                return true;
+            });
+        });
+        if (variantIndex === -1) {
+            return null;
+        }
+        return variants[variantIndex];
+    });
+    return {
+        variant,
+        options,
+        selectedOptions,
+    };
+}
+
+function useProductItem(errorHandler) {
+    return useItemLoader(api.getProduct, getApiErrorHandler(errorHandler, function (e) {
+        ui.useNotification('error', 'Ошибка', api.getApiErrorMessage(e, 'Товар не найден.'));
+    }));
+}
+function useProductCard(item) {
+    var _a;
+    const product = vue.ref({
+        id: item.id,
+        short_id: item.short_id,
+        category_id: Array.isArray(item.categories) && item.categories.length > 0 ? item.categories[0].id : null,
+        slug: item.slug,
+        name: item.name,
+        description: item.description,
+        images: item.media || [],
+        modifiers: item.modifiers || [],
+        modifiers_groups: item.modifiers_groups || [],
+        variants_count: ((_a = item.variants) === null || _a === void 0 ? void 0 : _a.length) || 0,
+        has_images: (item.media || []).length > 0,
+        has_modifiers: (item.modifiers || []).length > 0 || (item.modifiers_groups || []).length > 0,
+    });
+    const { variant, options, selectedOptions, } = useVariant(item.variants || []);
+    const { totalPrice, pricesRange, recalculate, } = useVariantPrice(item.variants || [], variant);
+    const { modifiers, selectedModifiers, modifiersHash, } = useModifiers(item, variant, recalculate);
+    return {
+        product,
+        variant,
+        options,
+        selectedOptions,
+        pricesRange,
+        totalPrice,
+        modifiers,
+        modifiersHash,
+        selectedModifiers,
+    };
+}
+
 function useProductsPricesRange(categoryId, errorHandler) {
     return useDataLoader(async () => api.getProductsPricesRange(categoryId), getApiErrorHandler(errorHandler, function (e) {
         ui.useNotification('error', 'Ошибка', api.getApiErrorMessage(e, 'Не удалось загрузить диапазон цен.'));
@@ -2572,7 +2954,7 @@ function useProductsPricesRangeFilters(categoryId, values) {
     };
 }
 
-var ProductsSourceType;
+exports.ProductsSourceType = void 0;
 (function (ProductsSourceType) {
     ProductsSourceType["Category"] = "category";
     ProductsSourceType["Collection"] = "collection";
@@ -2580,20 +2962,20 @@ var ProductsSourceType;
     ProductsSourceType["GroupContext"] = "group_context";
     ProductsSourceType["VariantOptionContext"] = "variant_option_context";
     ProductsSourceType["VariantOptionValueContext"] = "variant_option_value_context";
-})(ProductsSourceType || (ProductsSourceType = {}));
-var ProductsSorting;
+})(exports.ProductsSourceType || (exports.ProductsSourceType = {}));
+exports.ProductsSorting = void 0;
 (function (ProductsSorting) {
     ProductsSorting["Manual"] = "manual";
     ProductsSorting["NameAsc"] = "name";
     ProductsSorting["NameDesc"] = "-name";
     ProductsSorting["PriceAsc"] = "price";
     ProductsSorting["PriceDesc"] = "-price";
-})(ProductsSorting || (ProductsSorting = {}));
-var ProductsFiltersType;
+})(exports.ProductsSorting || (exports.ProductsSorting = {}));
+exports.ProductsFiltersType = void 0;
 (function (ProductsFiltersType) {
     ProductsFiltersType["Features"] = "features";
     ProductsFiltersType["FeaturesGroups"] = "featuresGroups";
-})(ProductsFiltersType || (ProductsFiltersType = {}));
+})(exports.ProductsFiltersType || (exports.ProductsFiltersType = {}));
 
 function getSourceParams(source, promotion) {
     if (source === null || !source.id || !source.type) {
@@ -2603,26 +2985,26 @@ function getSourceParams(source, promotion) {
         return {};
     }
     switch (source.type) {
-        case ProductsSourceType.Category:
+        case exports.ProductsSourceType.Category:
             return { category_id: source.id };
-        case ProductsSourceType.Collection:
+        case exports.ProductsSourceType.Collection:
             return { collection_id: source.id };
-        case ProductsSourceType.CategoryContext:
+        case exports.ProductsSourceType.CategoryContext:
             return {
                 context_type: 'category',
                 context_id: source.id,
             };
-        case ProductsSourceType.GroupContext:
+        case exports.ProductsSourceType.GroupContext:
             return {
                 context_type: 'group',
                 context_id: source.id,
             };
-        case ProductsSourceType.VariantOptionContext:
+        case exports.ProductsSourceType.VariantOptionContext:
             return {
                 context_type: 'variant_option',
                 context_id: source.id,
             };
-        case ProductsSourceType.VariantOptionValueContext:
+        case exports.ProductsSourceType.VariantOptionValueContext:
             return {
                 context_type: 'variant_option_value',
                 context_id: source.id,
@@ -2636,11 +3018,11 @@ function getSortingParams(sorting) {
         return {};
     }
     switch (sorting) {
-        case ProductsSorting.Manual:
-        case ProductsSorting.NameAsc:
-        case ProductsSorting.NameDesc:
-        case ProductsSorting.PriceAsc:
-        case ProductsSorting.PriceDesc:
+        case exports.ProductsSorting.Manual:
+        case exports.ProductsSorting.NameAsc:
+        case exports.ProductsSorting.NameDesc:
+        case exports.ProductsSorting.PriceAsc:
+        case exports.ProductsSorting.PriceDesc:
             return { order_by: sorting };
         default:
             return {};
@@ -2716,7 +3098,7 @@ function getCategoryIdFromSource(source) {
     if (!source || !source.type || !source.id || source.error) {
         return null;
     }
-    else if (source.type !== ProductsSourceType.Category) {
+    else if (source.type !== exports.ProductsSourceType.Category) {
         return null;
     }
     return source.id;
@@ -2727,9 +3109,9 @@ function useProductsList(config, errorHandler) {
     }));
     const store = useStoreStore();
     const cityId = vue.computed(() => store.cityId);
-    const sorting = vue.ref(config.value.sorting || ProductsSorting.Manual);
+    const sorting = vue.ref(config.value.sorting || exports.ProductsSorting.Manual);
     const search = vue.ref(config.value.search || '');
-    const { filters, load: loadFilters, items: features, } = config.value.filtersType === ProductsFiltersType.Features
+    const { filters, load: loadFilters, items: features, } = config.value.filtersType === exports.ProductsFiltersType.Features
         ? useFeaturesFilters(getCategoryIdFromSource(config.value.source), config.value.filters)
         : useFeaturesGroupsFilters(getCategoryIdFromSource(config.value.source), config.value.filters);
     const { filters: pricesFilters, load: loadPricesRange, range, } = useProductsPricesRangeFilters(getCategoryIdFromSource(config.value.source), config.value.pricesFilters);
@@ -2905,17 +3287,17 @@ function getProductsSource(source) {
         return null;
     }
     switch (injected) {
-        case ProductsSourceType.Category:
+        case exports.ProductsSourceType.Category:
             return getInjectedSource(exports.ZenkyInjection.Category, exports.ZenkyInjection.CategoryNotFound, injected);
-        case ProductsSourceType.Collection:
+        case exports.ProductsSourceType.Collection:
             return getInjectedSource(exports.ZenkyInjection.Collection, exports.ZenkyInjection.CollectionNotFound, injected);
-        case ProductsSourceType.CategoryContext:
+        case exports.ProductsSourceType.CategoryContext:
             return getInjectedSource(exports.ZenkyInjection.CategoryContext, exports.ZenkyInjection.CategoryContextNotFound, injected);
-        case ProductsSourceType.GroupContext:
+        case exports.ProductsSourceType.GroupContext:
             return getInjectedSource(exports.ZenkyInjection.GroupContext, exports.ZenkyInjection.GroupContextNotFound, injected);
-        case ProductsSourceType.VariantOptionContext:
+        case exports.ProductsSourceType.VariantOptionContext:
             return getInjectedSource(exports.ZenkyInjection.VariantOptionContext, exports.ZenkyInjection.VariantOptionContextNotFound, injected);
-        case ProductsSourceType.VariantOptionValueContext:
+        case exports.ProductsSourceType.VariantOptionValueContext:
             return getInjectedSource(exports.ZenkyInjection.VariantOptionValueContext, exports.ZenkyInjection.VariantOptionValueContextNotFound, injected);
         default:
             return null;
@@ -3111,6 +3493,7 @@ exports.getApiErrorHandler = getApiErrorHandler;
 exports.getExistedAddress = getExistedAddress;
 exports.getExistedAddressDisplayValue = getExistedAddressDisplayValue;
 exports.getFirstMedium = getFirstMedium;
+exports.getProductVariantsPricesRange = getProductVariantsPricesRange;
 exports.getProductsListParamsFromQuery = getProductsListParamsFromQuery;
 exports.getProductsListQueryParams = getProductsListQueryParams;
 exports.getProductsPaginationRequest = getProductsPaginationRequest;
@@ -3162,6 +3545,8 @@ 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;
@@ -3174,6 +3559,8 @@ 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;
@@ -3181,10 +3568,13 @@ 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;

package/dist/esm/index.js

@@ -1,6 +1,6 @@
 import { ref, computed, watch, unref, inject } from 'vue';
 import { debounce, isBoolean, cloneDeep } from 'lodash-es';
-import { getStore, getAddressSuggestions, getCategoriesTree, Visibility, getProductsCollections, getApiErrorMessage, getCategoryFeatures, getCategoryFeaturesGroups, getArticle, getArticles, getArticleCategories, getAuthenticationStatus, setAxiosToken, getCustomerProfile, login, requestPasswordResetCode, resetPassword, register, resendConfirmationCode, confirm, getApiErrorCode, getCustomerAddresses, deleteAddress, updateAddress, getOrder, getCustomerOrders, getCustomerPaymentMethods, deleteCustomerPaymentMethod, ImageType, getOffer, getOffers, setOrderCheckoutCustomer, getOrderSettings, createOrder, addOrderProductVariant, removeOrderProductVariant, confirmOrder, resendOrderConfirmationCode, setOrderCheckoutDelivery, setOrderCheckoutPayment, getOrderBonusesPaymentPreview, checkoutOrder, getOrderCheckoutTotal, getProductsPricesRange, getProducts, checkCompletedPromotions } from '@zenky/api';
+import { getStore, getAddressSuggestions, getCategoriesTree, Visibility, getProductsCollections, getApiErrorMessage, getCategoryFeatures, getCategoryFeaturesGroups, getArticle, getArticles, getArticleCategories, getAuthenticationStatus, setAxiosToken, getCustomerProfile, login, requestPasswordResetCode, resetPassword, register, resendConfirmationCode, confirm, getApiErrorCode, getCustomerAddresses, deleteAddress, updateAddress, getOrder, getCustomerOrders, getCustomerPaymentMethods, deleteCustomerPaymentMethod, ImageType, getOffer, getOffers, setOrderCheckoutCustomer, getOrderSettings, createOrder, addOrderProductVariant, removeOrderProductVariant, confirmOrder, resendOrderConfirmationCode, setOrderCheckoutDelivery, setOrderCheckoutPayment, getOrderBonusesPaymentPreview, checkoutOrder, getOrderCheckoutTotal, getProductVariantPrice, getProduct, getProductsPricesRange, getProducts, checkCompletedPromotions } from '@zenky/api';
 import { defineStore, storeToRefs } from 'pinia';
 import { useNotification } from '@zenky/ui';
 import { useCustomerLoaded, useCustomerAuthenticated, useCustomerLoggedOut, useOrderLoaded, useProductQuantityIncreased, useProductQuantityDecreased, usePromotionsCheckerStarted, usePromotionsCheckerCompleted, useDisplayOrderPromotionRewardSelection, useOrderPromotionsNotFound, useOrderPriceRecalculated, useOrderShouldBeReloaded, useOrderPromotionRewardsShouldBeReloaded, useOrderSubmitted } from '@zenky/events';
@@ -2513,6 +2513,388 @@ function useCheckoutTotal() {
     };
 }
 
+function useSingleModifier(props, emit) {
+    const value = computed({
+        get: () => props.modelValue,
+        set: (val) => emit('update:modelValue', val),
+    });
+    const checked = computed({
+        get: () => value.value.quantity > 0,
+        set: (val) => {
+            value.value.quantity = val ? 1 : 0;
+        },
+    });
+    const shouldUseQuantityControls = computed(() => props.modifier.max_quantity > 1);
+    const increase = () => {
+        if (props.limitReached) {
+            return;
+        }
+        value.value.quantity = Math.min(value.value.quantity + 1, props.modifier.max_quantity);
+    };
+    const decrease = () => {
+        value.value.quantity = Math.max(value.value.quantity - 1, props.modifier.min_quantity);
+    };
+    return {
+        value,
+        checked,
+        shouldUseQuantityControls,
+        increase,
+        decrease,
+    };
+}
+
+function getModifierQuantity(modifier, value) {
+    const index = value.value.findIndex((item) => item.modifier_id === modifier.modifier.id);
+    if (index === -1) {
+        return 0;
+    }
+    return value.value[index].quantity;
+}
+function getDefaultModifiersGroupModifiers(group, value) {
+    const modifiers = {};
+    group.modifiers.forEach((modifier) => {
+        const quantity = Array.isArray(value.value) ? getModifierQuantity(modifier, value) : 0;
+        modifiers[modifier.modifier.id] = {
+            quantity,
+            modifier_id: modifier.modifier.id,
+        };
+    });
+    return modifiers;
+}
+function getSelectedModifiers$1(group, modifiers) {
+    const selected = [];
+    Object.keys(modifiers).forEach((modifierId) => {
+        if (!modifiers[modifierId].quantity) {
+            return;
+        }
+        selected.push({
+            modifiers_group_id: group.group.id,
+            modifier_id: modifierId,
+            quantity: modifiers[modifierId].quantity,
+        });
+    });
+    return selected;
+}
+function useModifiersGroup(props, emit) {
+    const value = computed({
+        get: () => props.modelValue,
+        set: (val) => emit('update:modelValue', val),
+    });
+    const selectedModifier = ref('');
+    const modifiers = ref(getDefaultModifiersGroupModifiers(props.group, value));
+    const shouldUseQuantityControls = computed(() => props.group.max_quantity > 1);
+    const totalSelectedCount = computed(() => {
+        return value.value
+            .map((modifier) => modifier.quantity)
+            .reduce((current, total) => current + total, 0);
+    });
+    const limitReached = computed(() => {
+        if (!shouldUseQuantityControls.value) {
+            return selectedModifier.value !== '';
+        }
+        return totalSelectedCount.value >= props.group.max_quantity;
+    });
+    const requiredModifierIsMissing = computed(() => {
+        if (!props.group.is_required) {
+            return false;
+        }
+        else if (props.group.min_quantity === 0) {
+            return false;
+        }
+        return totalSelectedCount.value < props.group.min_quantity;
+    });
+    watch(selectedModifier, (val) => {
+        if (!val) {
+            value.value = [];
+            return;
+        }
+        value.value = [{
+                modifiers_group_id: props.group.group.id,
+                modifier_id: val,
+                quantity: 1,
+            }];
+    });
+    watch(modifiers, (val) => {
+        value.value = getSelectedModifiers$1(props.group, val);
+    }, { deep: true });
+    return {
+        selectedModifier,
+        modifiers,
+        shouldUseQuantityControls,
+        requiredModifierIsMissing,
+        limitReached,
+    };
+}
+
+function getModifiers(product, variant) {
+    const modifiers = {};
+    ((product === null || product === void 0 ? void 0 : product.modifiers) || []).forEach((modifier) => {
+        modifiers[modifier.modifier.id] = {
+            modifier_id: modifier.modifier.id,
+            quantity: 0,
+        };
+    });
+    ((product === null || product === void 0 ? void 0 : product.modifiers_groups) || []).forEach((group) => {
+        modifiers[group.group.id] = [];
+    });
+    if (!variant.value || !variant.value.selected_modifiers || !variant.value.selected_modifiers.modifiers) {
+        return modifiers;
+    }
+    else if (!variant.value.selected_modifiers.modifiers.length) {
+        return modifiers;
+    }
+    variant.value.selected_modifiers.modifiers.forEach((modifier) => {
+        if (typeof modifier.modifiers_group_id !== 'undefined' && modifier.modifiers_group_id) {
+            modifiers[modifier.modifiers_group_id].push(modifier);
+        }
+        else if (typeof modifier.modifier_id !== 'undefined' && modifier.modifier_id) {
+            modifiers[modifier.modifier_id] = {
+                modifier_id: modifier.modifier_id,
+                quantity: modifier.quantity,
+            };
+        }
+    });
+    return modifiers;
+}
+function getSelectedModifiers(modifiers) {
+    const selected = [];
+    Object.keys(modifiers.value).forEach((modifierId) => {
+        const isGroup = Array.isArray(modifiers.value[modifierId]);
+        if (!isGroup && !modifiers.value[modifierId].quantity) {
+            return;
+        }
+        else if (!isGroup) {
+            selected.push({
+                modifier_id: modifierId,
+                quantity: modifiers.value[modifierId].quantity,
+            });
+            return;
+        }
+        modifiers.value[modifierId].forEach((modifier) => {
+            if (!modifier.modifier_id || !modifier.quantity || !modifier.modifiers_group_id) {
+                return;
+            }
+            selected.push({
+                modifiers_group_id: modifier.modifiers_group_id,
+                modifier_id: modifier.modifier_id,
+                quantity: modifier.quantity,
+            });
+        });
+    });
+    return selected;
+}
+function useModifiers(product, variant, recalculate) {
+    var _a, _b;
+    const modifiersHash = ref(((_b = (_a = variant.value) === null || _a === void 0 ? void 0 : _a.selected_modifiers) === null || _b === void 0 ? void 0 : _b.hash) || null);
+    const modifiers = ref(getModifiers(product, variant));
+    const selectedModifiers = computed(() => getSelectedModifiers(modifiers));
+    watch(variant, () => {
+        modifiers.value = getModifiers(product, variant);
+    });
+    watch(selectedModifiers, async () => {
+        const hash = await recalculate(selectedModifiers);
+        if (hash === null) {
+            return;
+        }
+        modifiersHash.value = hash;
+    });
+    return {
+        modifiers,
+        selectedModifiers,
+        modifiersHash,
+    };
+}
+
+async function recalculatePrice(variant, modifiers) {
+    if (!variant.value) {
+        return null;
+    }
+    else if (!modifiers.value.length) {
+        return null;
+    }
+    const { cityId } = storeToRefs(useStoreStore());
+    try {
+        return await getProductVariantPrice(variant.value.product_id, variant.value.id, modifiers.value, {
+            city_id: cityId.value || undefined,
+        });
+    }
+    catch (e) {
+        //
+    }
+    return null;
+}
+function getProductVariantsPricesRange(variants) {
+    if (!variants.length) {
+        return null;
+    }
+    const sorted = [...variants].sort((first, second) => Math.sign(first.price.value - second.price.value));
+    return {
+        min: sorted[0].price,
+        max: sorted[sorted.length - 1].price,
+    };
+}
+function useVariantPrice(variants, variant) {
+    const result = ref(null);
+    const recalculating = ref(false);
+    const totalPrice = computed(() => {
+        if (result.value !== null) {
+            return {
+                recalculated: true,
+                recalculating: recalculating.value,
+                price: result.value.price,
+                original_price: result.value.original_price,
+                has_discount: result.value.has_discount,
+                discount_id: result.value.discount_id,
+                discount_difference: result.value.discount_difference,
+                discount_percentage: result.value.discount_percentage,
+            };
+        }
+        else if (!variant.value) {
+            return null;
+        }
+        return {
+            recalculated: false,
+            recalculating: recalculating.value,
+            price: variant.value.price,
+            original_price: variant.value.original_price,
+            has_discount: variant.value.has_discount,
+            discount_id: variant.value.discount_id,
+            discount_difference: variant.value.discount_difference,
+            discount_percentage: variant.value.discount_percentage,
+        };
+    });
+    const pricesRange = computed(() => getProductVariantsPricesRange(variants));
+    const recalculate = async (modifiers) => {
+        if (recalculating.value) {
+            return null;
+        }
+        recalculating.value = true;
+        result.value = await recalculatePrice(variant, modifiers);
+        recalculating.value = false;
+        return result.value !== null ? result.value.modifiers_hash : null;
+    };
+    return {
+        totalPrice,
+        pricesRange,
+        recalculating,
+        recalculate,
+    };
+}
+
+function getOptionsList(variants) {
+    const options = [];
+    if (variants.length <= 1) {
+        return options;
+    }
+    variants.forEach((variant) => {
+        if (!variant.option_values || !variant.option_values.length) {
+            return;
+        }
+        variant.option_values.forEach((optionValue) => {
+            if (!optionValue.option || !optionValue.option.id) {
+                return;
+            }
+            const optionIndex = options.findIndex((option) => { var _a; return option.id === ((_a = optionValue.option) === null || _a === void 0 ? void 0 : _a.id); });
+            if (optionIndex === -1) {
+                options.push({
+                    id: optionValue.option.id,
+                    name: optionValue.option.name,
+                    type: optionValue.option.type,
+                    values: [optionValue],
+                });
+                return;
+            }
+            const valueIndex = options[optionIndex].values.findIndex((item) => item.id === optionValue.id);
+            if (valueIndex !== -1) {
+                return;
+            }
+            options[optionIndex].values.push(optionValue);
+        });
+    });
+    return options;
+}
+function useVariant(variants) {
+    const options = ref(getOptionsList(variants));
+    const selectedOptions = ref({});
+    options.value.forEach((option) => {
+        selectedOptions.value[option.id] = option.values.length > 0 ? option.values[0].id : null;
+    });
+    const variant = computed(() => {
+        if (!Array.isArray(variants) || !variants.length) {
+            return null;
+        }
+        else if (variants.length === 1) {
+            return variants[0];
+        }
+        else if (!Object.keys(selectedOptions.value).length) {
+            return variants[0];
+        }
+        const variantIndex = variants.findIndex((item) => {
+            if (!item.option_values || !item.option_values.length) {
+                return false;
+            }
+            return item.option_values.every((optionValue) => {
+                if (!optionValue.option || !optionValue.option.id) {
+                    return false;
+                }
+                else if (typeof selectedOptions.value[optionValue.option.id] === 'undefined') {
+                    return false;
+                }
+                else if (selectedOptions.value[optionValue.option.id] !== optionValue.id) {
+                    return false;
+                }
+                return true;
+            });
+        });
+        if (variantIndex === -1) {
+            return null;
+        }
+        return variants[variantIndex];
+    });
+    return {
+        variant,
+        options,
+        selectedOptions,
+    };
+}
+
+function useProductItem(errorHandler) {
+    return useItemLoader(getProduct, getApiErrorHandler(errorHandler, function (e) {
+        useNotification('error', 'Ошибка', getApiErrorMessage(e, 'Товар не найден.'));
+    }));
+}
+function useProductCard(item) {
+    var _a;
+    const product = ref({
+        id: item.id,
+        short_id: item.short_id,
+        category_id: Array.isArray(item.categories) && item.categories.length > 0 ? item.categories[0].id : null,
+        slug: item.slug,
+        name: item.name,
+        description: item.description,
+        images: item.media || [],
+        modifiers: item.modifiers || [],
+        modifiers_groups: item.modifiers_groups || [],
+        variants_count: ((_a = item.variants) === null || _a === void 0 ? void 0 : _a.length) || 0,
+        has_images: (item.media || []).length > 0,
+        has_modifiers: (item.modifiers || []).length > 0 || (item.modifiers_groups || []).length > 0,
+    });
+    const { variant, options, selectedOptions, } = useVariant(item.variants || []);
+    const { totalPrice, pricesRange, recalculate, } = useVariantPrice(item.variants || [], variant);
+    const { modifiers, selectedModifiers, modifiersHash, } = useModifiers(item, variant, recalculate);
+    return {
+        product,
+        variant,
+        options,
+        selectedOptions,
+        pricesRange,
+        totalPrice,
+        modifiers,
+        modifiersHash,
+        selectedModifiers,
+    };
+}
+
 function useProductsPricesRange(categoryId, errorHandler) {
     return useDataLoader(async () => getProductsPricesRange(categoryId), getApiErrorHandler(errorHandler, function (e) {
         useNotification('error', 'Ошибка', getApiErrorMessage(e, 'Не удалось загрузить диапазон цен.'));
@@ -3096,4 +3478,4 @@ function subscribeToOrderEvents(order) {
     });
 }
 
-export { AuthenticationEvent, AuthenticationResultType, AuthenticationStage, CheckoutStage, ZenkyInjection, ZenkyWebsocketEvent, createStorage, createWebsocketsConnection, getAddressForm, getApiErrorHandler, getExistedAddress, getExistedAddressDisplayValue, getFirstMedium, getProductsListParamsFromQuery, getProductsListQueryParams, getProductsPaginationRequest, getProductsSource, getSelectedAddress, getSelectedAddressDisplayValue, getStockAddress, getStockSchedule, getStorage, getUpdatedVariants, getWebsocketsConnection, initializeOrderCustomer, initializePromotions, subscribeToOrderEvents, useAddressFormValue, useArticleCategoriesList, useArticleItem, useArticlesList, useAuthenticationForm, useAuthenticationStatusChecker, useBillSuggestions, useCategories, useCategoriesStore, useCategoriesTree, useCategory, useCategoryFeaturesGroupsList, useCategoryFeaturesList, useCheckoutConfirmation, useCheckoutSummary, useCheckoutTotal, useCollection, useCollections, useCollectionsStore, useCustomer, useCustomerCheckoutForm, useCustomerStore, useDadata, useDataDestroyer, useDataLoader, useDeliveryAddressDestroyer, useDeliveryAddressesList, useDeliveryCheckoutForm, useDeliveryPaymentsForm, useEditAddressForm, useFeaturesFilters, useFeaturesGroupsFilters, useFlatCategoriesTree, useItemLoader, useListLoader, useLogin, useLogout, useOfferItem, useOffersList, useOrderCheckout, useOrderItem, useOrderStore, useOrderVariants, useOrdersList, usePaginatedLoader, usePasswordReset, usePaymentMethodDestroyer, usePaymentMethodsList, usePhoneConfirmation, useProductsList, useProductsPricesRange, useProductsPricesRangeFilters, usePromotionsStore, useRegistration, useReversedTree, useRewardsSelector, useSplittedCategoriesTree, useStateDataLoader, useStoreStore, useSuggestionsRestrictedToCity, useTotalPrice, useTotalQuantity, useVariantControls };
+export { AuthenticationEvent, AuthenticationResultType, AuthenticationStage, CheckoutStage, ProductsFiltersType, ProductsSorting, ProductsSourceType, ZenkyInjection, ZenkyWebsocketEvent, createStorage, createWebsocketsConnection, getAddressForm, getApiErrorHandler, getExistedAddress, getExistedAddressDisplayValue, getFirstMedium, getProductVariantsPricesRange, getProductsListParamsFromQuery, getProductsListQueryParams, getProductsPaginationRequest, getProductsSource, getSelectedAddress, getSelectedAddressDisplayValue, getStockAddress, getStockSchedule, getStorage, getUpdatedVariants, getWebsocketsConnection, initializeOrderCustomer, initializePromotions, subscribeToOrderEvents, useAddressFormValue, useArticleCategoriesList, useArticleItem, useArticlesList, useAuthenticationForm, useAuthenticationStatusChecker, useBillSuggestions, useCategories, useCategoriesStore, useCategoriesTree, useCategory, useCategoryFeaturesGroupsList, useCategoryFeaturesList, useCheckoutConfirmation, useCheckoutSummary, useCheckoutTotal, useCollection, useCollections, useCollectionsStore, useCustomer, useCustomerCheckoutForm, useCustomerStore, useDadata, useDataDestroyer, useDataLoader, useDeliveryAddressDestroyer, useDeliveryAddressesList, useDeliveryCheckoutForm, useDeliveryPaymentsForm, useEditAddressForm, useFeaturesFilters, useFeaturesGroupsFilters, useFlatCategoriesTree, useItemLoader, useListLoader, useLogin, useLogout, useModifiers, useModifiersGroup, useOfferItem, useOffersList, useOrderCheckout, useOrderItem, useOrderStore, useOrderVariants, useOrdersList, usePaginatedLoader, usePasswordReset, usePaymentMethodDestroyer, usePaymentMethodsList, usePhoneConfirmation, useProductCard, useProductItem, useProductsList, useProductsPricesRange, useProductsPricesRangeFilters, usePromotionsStore, useRegistration, useReversedTree, useRewardsSelector, useSingleModifier, useSplittedCategoriesTree, useStateDataLoader, useStoreStore, useSuggestionsRestrictedToCity, useTotalPrice, useTotalQuantity, useVariant, useVariantControls, useVariantPrice };

package/dist/zenky.d.ts

@@ -1,7 +1,7 @@
 import * as vue from 'vue';
-import { Ref, ComputedRef } from 'vue';
+import { Ref, ComputedRef, WritableComputedRef } from 'vue';
 import * as _zenky_api from '@zenky/api';
-import { PaginationRequest, Pagination, PaginatedResponse, ResourceRequest, Address, City, NestedCategory, ProductsCollection, Feature, FeaturesGroupContainer, Article, ArticlesPaginationRequest, ArticleCategory, ArticleCategoriesPaginationRequest, Customer, AuthenticationPhone, Order, OrderCredentials, CustomerPaymentMethod, Medium, Image, Offer, OffersPaginationRequest, OrderSettings, OrderCheckoutTotal, ProductVariant, OrderProductVariant, Product, ProductsPricesRange, ProductsPaginationRequest, Schedule, Stock, Store, StoreSettings } from '@zenky/api';
+import { PaginationRequest, Pagination, PaginatedResponse, ResourceRequest, Address, City, NestedCategory, ProductsCollection, Feature, FeaturesGroupContainer, Article, ArticlesPaginationRequest, ArticleCategory, ArticleCategoriesPaginationRequest, Customer, AuthenticationPhone, Order, OrderCredentials, CustomerPaymentMethod, Medium, Image, Offer, OffersPaginationRequest, OrderSettings, OrderCheckoutTotal, ProductVariant, OrderProductVariant, ProductModifiersGroup, ProductModifier, ProductVariantPriceCalculation, Enum, VariantOptionValue, Product, ProductRequest, ProductsPaginationRequest, ProductsPricesRange, Schedule, Stock, Store, StoreSettings } from '@zenky/api';
 import * as pinia from 'pinia';
 import Pusher from 'pusher-js';
 
@@ -9991,6 +9991,122 @@ declare const useVariantControls: (variant: Ref<ProductVariant>, modifiers: Ref<
 
 declare function getUpdatedVariants(currentOrder: Order, order: Order): OrderProductVariant[];
 
+interface ProductModifierModel {
+    quantity: number;
+    modifier_id: string;
+}
+interface ModifiersGroupModifiersList {
+    [x: string]: ProductModifierModel;
+}
+interface ProductModifiersGroupModifierModel {
+    modifiers_group_id: string | null;
+    modifier_id: string | null;
+    quantity: number;
+}
+interface ModifiersGroupProps {
+    modelValue: ProductModifiersGroupModifierModel[];
+    group: ProductModifiersGroup;
+}
+interface SingleModifierProps {
+    modelValue: ProductModifierModel;
+    modifier: ProductModifier;
+    limitReached: boolean;
+}
+interface ProductCardModifiersList {
+    [x: string]: ProductModifierModel | ProductModifiersGroupModifierModel[];
+}
+interface SelectedProductModifier {
+    modifier_id: string;
+    quantity: number;
+    modifiers_group_id?: string;
+}
+declare type ProductVariantPriceCalcuator = (modifiers: Ref<SelectedProductModifier[]>) => Promise<string | null>;
+interface CalculatedProductVariantPrice extends ProductVariantPriceCalculation {
+    recalculated: boolean;
+    recalculating: boolean;
+}
+interface ProductCardVariantOption {
+    id: string;
+    name: string | null;
+    type: Enum | null;
+    values: VariantOptionValue[];
+}
+interface SelectedVariantOptionsList {
+    [x: string]: string | null;
+}
+interface ProductCardProduct {
+    id: string;
+    short_id: string | null;
+    category_id: string | null;
+    slug: string | null;
+    name: string | null;
+    description: string | null;
+    images: Medium[];
+    modifiers: ProductModifier[];
+    modifiers_groups: ProductModifiersGroup[];
+    variants_count: number;
+    has_images: boolean;
+    has_modifiers: boolean;
+}
+
+declare function useSingleModifier(props: SingleModifierProps, emit: (event: string, data: any) => any): {
+    value: WritableComputedRef<ProductModifierModel>;
+    checked: WritableComputedRef<boolean>;
+    shouldUseQuantityControls: ComputedRef<boolean>;
+    increase: () => void;
+    decrease: () => void;
+};
+
+declare function useModifiersGroup(props: ModifiersGroupProps, emit: (event: string, data: any) => any): {
+    selectedModifier: Ref<string>;
+    modifiers: Ref<ModifiersGroupModifiersList>;
+    shouldUseQuantityControls: ComputedRef<boolean>;
+    requiredModifierIsMissing: ComputedRef<boolean>;
+    limitReached: ComputedRef<boolean>;
+};
+
+declare function useModifiers(product: Product, variant: ComputedRef<ProductVariant | null>, recalculate: ProductVariantPriceCalcuator): {
+    modifiers: Ref<ProductCardModifiersList>;
+    selectedModifiers: Ref<SelectedProductModifier[]>;
+    modifiersHash: Ref<string | null>;
+};
+
+declare function getProductVariantsPricesRange(variants: ProductVariant[]): {
+    min: _zenky_api.Price;
+    max: _zenky_api.Price;
+} | null;
+declare function useVariantPrice(variants: ProductVariant[], variant: ComputedRef<ProductVariant | null>): {
+    totalPrice: ComputedRef<CalculatedProductVariantPrice | null>;
+    pricesRange: ComputedRef<{
+        min: _zenky_api.Price;
+        max: _zenky_api.Price;
+    } | null>;
+    recalculating: Ref<boolean>;
+    recalculate: ProductVariantPriceCalcuator;
+};
+
+declare function useProductItem(errorHandler?: OptionalApiErrorHandler): ItemLoader<Product, string, ProductRequest>;
+declare function useProductCard(item: Product): {
+    product: Ref<ProductCardProduct>;
+    variant: vue.ComputedRef<_zenky_api.ProductVariant | null>;
+    options: Ref<ProductCardVariantOption[]>;
+    selectedOptions: Ref<SelectedVariantOptionsList>;
+    pricesRange: vue.ComputedRef<{
+        min: _zenky_api.Price;
+        max: _zenky_api.Price;
+    } | null>;
+    totalPrice: vue.ComputedRef<CalculatedProductVariantPrice | null>;
+    modifiers: Ref<ProductCardModifiersList>;
+    modifiersHash: Ref<string | null>;
+    selectedModifiers: Ref<SelectedProductModifier[]>;
+};
+
+declare function useVariant(variants: ProductVariant[]): {
+    variant: ComputedRef<ProductVariant | null>;
+    options: Ref<ProductCardVariantOption[]>;
+    selectedOptions: Ref<SelectedVariantOptionsList>;
+};
+
 declare enum ProductsSourceType {
     Category = "category",
     Collection = "collection",
@@ -10011,6 +10127,9 @@ interface ProductsSource {
     id?: string;
     error?: boolean;
 }
+interface InjectedProductsSource {
+    id: string;
+}
 interface ProductsFilters {
     [key: string]: string[];
 }
@@ -10188,4 +10307,4 @@ declare function createWebsocketsConnection(store: Store): Pusher;
 declare function getWebsocketsConnection(): Pusher;
 declare function subscribeToOrderEvents(order: Order): void;
 
-export { AddressForm, AddressFormValue, AddressFormValueProvider, ApiErrorHandler, AuthenticationEvent, AuthenticationForm, AuthenticationFormProvider, AuthenticationResult, AuthenticationResultType, AuthenticationStage, AuthenticationStatusCheckerProvider, CategoriesProvider, CategoriesState, CategoriesTreeProvider, CategoryProvider, CheckoutStage, CollectionsState, ConfirmableDataDestroyer, ConfirmationProvider, CustomerStore, DadataProvider, DataDestroyer, DataDestroyerHandler, DataLoader, DataProvider, EditAddressFormProvider, EmitAuthenticationEvent, FlatCategoriesTreeProvider, FlattenNestedCategory, ItemLoader, ItemProvider, ListLoader, ListProvider, LoaderState, LoginProvider, LogoutProvider, OptionalApiErrorHandler, OrderInclusions, OrderProductVariantPromotion, OrderSettingsState, OrderStoreState, PaginatedItemsProvider, PaginatedLoader, PaginatedLoaderState, PasswordResetProvider, ProductsCollectionProvider, ProductsCollectionsProvider, PromotionsCheckerCompletedPayload, PromotionsCheckerSelector, PromotionsRewardsSelectorProvider, PromotionsSelector, PromotionsSelectorContext, PromotionsSelectorOffer, PromotionsStoreState, RegistrationProvider, ReversedTreeProvider, SplittedCategoriesTreeProvider, StateDataLoader, StateDataLoaderState, StoreState, ZenkyInjection, ZenkyStorage, ZenkyWebsocketEvent, createStorage, createWebsocketsConnection, getAddressForm, getApiErrorHandler, getExistedAddress, getExistedAddressDisplayValue, getFirstMedium, getProductsListParamsFromQuery, getProductsListQueryParams, getProductsPaginationRequest, getProductsSource, getSelectedAddress, getSelectedAddressDisplayValue, getStockAddress, getStockSchedule, getStorage, getUpdatedVariants, getWebsocketsConnection, initializeOrderCustomer, initializePromotions, subscribeToOrderEvents, useAddressFormValue, useArticleCategoriesList, useArticleItem, useArticlesList, useAuthenticationForm, useAuthenticationStatusChecker, useBillSuggestions, useCategories, useCategoriesStore, useCategoriesTree, useCategory, useCategoryFeaturesGroupsList, useCategoryFeaturesList, useCheckoutConfirmation, useCheckoutSummary, useCheckoutTotal, useCollection, useCollections, useCollectionsStore, useCustomer, useCustomerCheckoutForm, useCustomerStore, useDadata, useDataDestroyer, useDataLoader, useDeliveryAddressDestroyer, useDeliveryAddressesList, useDeliveryCheckoutForm, useDeliveryPaymentsForm, useEditAddressForm, useFeaturesFilters, useFeaturesGroupsFilters, useFlatCategoriesTree, useItemLoader, useListLoader, useLogin, useLogout, useOfferItem, useOffersList, useOrderCheckout, useOrderItem, useOrderStore, useOrderVariants, useOrdersList, usePaginatedLoader, usePasswordReset, usePaymentMethodDestroyer, usePaymentMethodsList, usePhoneConfirmation, useProductsList, useProductsPricesRange, useProductsPricesRangeFilters, usePromotionsStore, useRegistration, useReversedTree, useRewardsSelector, useSplittedCategoriesTree, useStateDataLoader, useStoreStore, useSuggestionsRestrictedToCity, useTotalPrice, useTotalQuantity, useVariantControls };
+export { AddressForm, AddressFormValue, AddressFormValueProvider, ApiErrorHandler, AuthenticationEvent, AuthenticationForm, AuthenticationFormProvider, AuthenticationResult, AuthenticationResultType, AuthenticationStage, AuthenticationStatusCheckerProvider, CalculatedProductVariantPrice, CategoriesProvider, CategoriesState, CategoriesTreeProvider, CategoryProvider, CheckoutStage, CollectionsState, ConfirmableDataDestroyer, ConfirmationProvider, CustomerStore, DadataProvider, DataDestroyer, DataDestroyerHandler, DataLoader, DataProvider, EditAddressFormProvider, EmitAuthenticationEvent, FlatCategoriesTreeProvider, FlattenNestedCategory, InjectedProductsSource, ItemLoader, ItemProvider, ListLoader, ListProvider, LoaderState, LoginProvider, LogoutProvider, ModifiersGroupModifiersList, ModifiersGroupProps, OptionalApiErrorHandler, OrderInclusions, OrderProductVariantPromotion, OrderSettingsState, OrderStoreState, PaginatedItemsProvider, PaginatedLoader, PaginatedLoaderState, PasswordResetProvider, ProductCardModifiersList, ProductCardProduct, ProductCardVariantOption, ProductModifierModel, ProductModifiersGroupModifierModel, ProductVariantPriceCalcuator, ProductsCollectionProvider, ProductsCollectionsProvider, ProductsFilters, ProductsFiltersType, ProductsListConfig, ProductsListProvider, ProductsLoader, ProductsPriceFilters, ProductsPromotion, ProductsRequestCallback, ProductsSorting, ProductsSource, ProductsSourceType, PromotionsCheckerCompletedPayload, PromotionsCheckerSelector, PromotionsRewardsSelectorProvider, PromotionsSelector, PromotionsSelectorContext, PromotionsSelectorOffer, PromotionsStoreState, RegistrationProvider, ReversedTreeProvider, SelectedProductModifier, SelectedVariantOptionsList, SingleModifierProps, SplittedCategoriesTreeProvider, StateDataLoader, StateDataLoaderState, StoreState, ZenkyInjection, ZenkyStorage, ZenkyWebsocketEvent, createStorage, createWebsocketsConnection, getAddressForm, getApiErrorHandler, getExistedAddress, getExistedAddressDisplayValue, getFirstMedium, getProductVariantsPricesRange, getProductsListParamsFromQuery, getProductsListQueryParams, getProductsPaginationRequest, getProductsSource, getSelectedAddress, getSelectedAddressDisplayValue, getStockAddress, getStockSchedule, getStorage, getUpdatedVariants, getWebsocketsConnection, initializeOrderCustomer, initializePromotions, subscribeToOrderEvents, useAddressFormValue, useArticleCategoriesList, useArticleItem, useArticlesList, useAuthenticationForm, useAuthenticationStatusChecker, useBillSuggestions, useCategories, useCategoriesStore, useCategoriesTree, useCategory, useCategoryFeaturesGroupsList, useCategoryFeaturesList, useCheckoutConfirmation, useCheckoutSummary, useCheckoutTotal, useCollection, useCollections, useCollectionsStore, useCustomer, useCustomerCheckoutForm, useCustomerStore, useDadata, useDataDestroyer, useDataLoader, useDeliveryAddressDestroyer, useDeliveryAddressesList, useDeliveryCheckoutForm, useDeliveryPaymentsForm, useEditAddressForm, useFeaturesFilters, useFeaturesGroupsFilters, useFlatCategoriesTree, useItemLoader, useListLoader, useLogin, useLogout, useModifiers, useModifiersGroup, useOfferItem, useOffersList, useOrderCheckout, useOrderItem, useOrderStore, useOrderVariants, useOrdersList, usePaginatedLoader, usePasswordReset, usePaymentMethodDestroyer, usePaymentMethodsList, usePhoneConfirmation, useProductCard, useProductItem, useProductsList, useProductsPricesRange, useProductsPricesRangeFilters, usePromotionsStore, useRegistration, useReversedTree, useRewardsSelector, useSingleModifier, useSplittedCategoriesTree, useStateDataLoader, useStoreStore, useSuggestionsRestrictedToCity, useTotalPrice, useTotalQuantity, useVariant, useVariantControls, useVariantPrice };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zenky/storefront-vue",
-  "version": "0.9.39",
+  "version": "0.9.40",
   "description": "Zenky Storefront library for Vue 3.",
   "author": "Timur Zurbaev <hello@zurbaev.ru>",
   "license": "MIT",
@@ -19,7 +19,7 @@
     "Zenky"
   ],
   "peerDependencies": {
-    "@zenky/api": "^0.9.50",
+    "@zenky/api": "^0.9.51",
     "@zenky/events": "^1.0.2",
     "@zenky/ui": "^0.9.63",
     "date-fns": "^2.29.2",