+33 444 44 88 00 8h00 à 21h00 (7j/7)

function amXsearchProductsComponent() {
        const postFormRequest = (postUrl, id) => {
            const req = fetch(BASE_URL + postUrl, {
                "headers": {
                    "content-type": "application/x-www-form-urlencoded; charset=UTF-8",
                },
                "body": "form_key=" + hyva.getFormKey() + "&product=" + id + "&uenc=" + hyva.getUenc(),
                "method": "POST",
                "mode": "cors",
                "credentials": "include"
            });

req.finally(() => this.isLoading = false);

return req;
        }

return {
            mutationAddToCartQuery: "mutation addProductsToCart($cartId: String!, $cartItems: [CartItemInput!]!) {addProductsToCart(\n                cartId: $cartId,\n                cartItems: $cartItems\n                ) {\n                    cart {\n                        items {\n                            product {\n                                name\n                            }\n                        }\n                        total_quantity\n                    }\n                    user_errors {\n                        code\n                        message\n                    }\n                }}",
            mutationAddToWishlistQuery: "mutation addProductsToWishlist($wishlistId: ID!, $wishlistItems: [WishlistItemInput!]!) {addProductsToWishlist(\n                wishlistId: $wishlistId,\n                wishlistItems: $wishlistItems\n                ) {\n                    wishlist {\n                        items {\n                            id\n                            product {\n                                name\n                            }\n                        }\n                        items_count\n                    }\n                    user_errors {\n                        code\n                        message\n                    }\n                }}",
            mutationAddToCompareListQuery: "mutation addProductsToCompareList($uid: ID!, $products: [ID!]!) {addProductsToCompareList(input: {\n                uid: $uid,\n                products: $products\n            }) {\n                items {\n                    product {\n                        name\n                    }\n                }\n                item_count\n            }}",

sliderInitialization(event) {
                this[event.detail.key] = event.detail.value;
            },

getResultProductsCount() {
                const suggestions = this.sections.products;
                const totalCount = suggestions?.total_count ?? 0;
                const itemsCount = suggestions?.items?.length ?? 0;

return totalCount > 0 ? totalCount - itemsCount : 0;
            },

processProductName(value) {
                if (value.items) {
                    value.items = value.items.map(item => {
                        item.name = this.addHighlight(item, 'name');
                        item.sku = this.addHighlight(item, 'sku');
                        item.name = this.truncateWithDots(item.name, this.productNameMaxLength, true);

return item;
                    });
                }
                return value;
            },

addHighlight(product, key = 'name') {
                const name = product[key];
                const { latestQuery } = this;
                const queries = latestQuery.toLowerCase().split(" ");

let highlightedName = name;

for (const query of queries) {
                    const safeQuery = query.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
                    const regex = new RegExp(`(?!<[^>]*)(${safeQuery})(?![^<]*>)`, "gi");
                    highlightedName = highlightedName.replace(regex, match => `<span class="amsearch-highlight">${match}</span>`);
                }

return highlightedName;
            },

truncateWithDots(str, maxLength, returnOriginal = false) {
                if (maxLength === '' || maxLength < 1) {
                    return returnOriginal ? str : "";
                }

let output = [];
                let tagBuffer = [];
                let count = 0;
                let inTag = false;

for (const char of str) {
                    if (char === "<") {
                        inTag = true;
                    }

if (inTag) {
                        tagBuffer.push(char);
                    } else {
                        count++;
                    }

if (char === ">") {
                        inTag = false;
                        output.push(tagBuffer.join(""));
                        tagBuffer = [];
                    } else if (!inTag) {
                        output.push(char);
                    }

if (count >= maxLength) {
                        break;
                    }
                }

if (count >= maxLength) {
                    output.push("...");
                }

// Close any unclosed tags
                while (tagBuffer.length > 0) {
                    const closingTagPos = str.indexOf(">", str.indexOf(tagBuffer.join("")) + tagBuffer.length);
                    if (closingTagPos !== -1) {
                        output.push(str.slice(str.indexOf(tagBuffer.join("")) + tagBuffer.length, closingTagPos + 1));
                        tagBuffer = [];
                    } else {
                        break;
                    }
                }

return output.join("");
            },

getProductUrl(product) {
                return window.BASE_URL + product.url_key + (product.url_suffix || '');
            },

getProductImageUrl(product) {
                const imageUrl = product.small_image.url;
                let mediaURL = this.config.customMediaUrl || '';

if (mediaURL.includes('/media') && imageUrl.startsWith('media/')) {
                    mediaURL = mediaURL.replace('/media', '');
                }

if (imageUrl.includes('://')) {
                    return imageUrl;
                }

const productImageUrl = mediaURL + imageUrl;

if (productImageUrl.includes('/product/placeholder/')) {
                    return productImageUrl.replace(/\/media(?=\/static)/, '');
                }

return productImageUrl;
            },

/**
             * @param Product {id: string}
             */
            addToWishlist({id}) {
                postFormRequest('wishlist/index/add/', id).then(response => {
                    if (response.redirected) {
                        window.location.href = response.url;
                    } else if (response.ok) {
                        return response.json();
                    } else {
                        typeof window.dispatchMessages !== "undefined" && window.dispatchMessages(
                            [{
                                type: "warning",
                                text: "Impossible d'ajouter l'article à la liste de souhaits."
                            }], 5000
                        );
                    }
                }).then(response => {
                    if (!response) { return }
                    typeof window.dispatchMessages !== "undefined" && window.dispatchMessages(
                        [{
                            type: response.success ? "success" : "error",
                            text: response.success
                                ? "Produit a été ajouté à votre liste de souhaits." : response.error_message
                        }], 5000
                    );
                    window.dispatchEvent(new CustomEvent("reload-customer-section-data"));
                }).catch(function (error) {
                    typeof window.dispatchMessages !== "undefined" && window.dispatchMessages(
                        [{
                            type: "error",
                            text: error
                        }], 5000
                    );
                });
            },

/**
             * @param Product {id: string}
             */
            addToCompare({id}) {
                postFormRequest('catalog/product_compare/add', id)
                    .then(response => {
                        if (response.redirected) {
                            window.location.href = response.url;
                        }
                        this.isLoading = false;
                    }).catch(error => {
                        this.isLoading = false;
                        typeof window.dispatchMessages !== "undefined" && window.dispatchMessages(
                            [{
                                type: "error",
                                text: error
                            }], 5000
                        );
                    });
            },

/**
             *
             * @param product
             */
            getRating(product) {
                const { rating_summary } = product;
                product.ratingData = {
                    ratingSteps: 5,
                    starsFilled: Math.floor(+rating_summary / 100 * 5),
                    starFragment: rating_summary / 100 * 5 % 1,
                    starsEmpty: Math.floor(5 - (+rating_summary / 100 * 5)),
                    yellowHex: '#f6e05e',
                    greyHex: '#cbd5e0'
                };
                return product;
            },

/**
             * Compatibility function for Amasty_AjaxCart module
             *
             * @param id
             * @param $event
             */
            addToCart({id}, $event) {
                                const createFormInput = (name, value) => {
                    const input = document.createElement('input');
                    input.name = name;
                    input.value = value;
                    input.type = 'hidden';

return input;
                }

const form = document.createElement('form');
                form.appendChild(createFormInput('product', id));
                form.appendChild(createFormInput('qty', 1));
                form.appendChild(createFormInput('form_key', hyva.getFormKey()));

window.dispatchEvent(
                    new CustomEvent('amcart-add-to-cart-action', { detail: form })
                );

this.$watch('searchOpen', (v, oldValue) => {
                    const amCartDialog = document.querySelector(`[x-spread="overlay('amcart-dialog-popup')"]`);
                    const amCartConfirmDialog = document.querySelector(`[x-spread="overlay('amcart-confirmation-popup')"]`);
                    this.searchOpen = (
                        oldValue === true
                        && (amCartDialog.style.display !== 'none'
                            || amCartConfirmDialog.style.display !== 'none'
                        ) ? true : v
                    );

});
                            }
        }
    }
</script>
<script>
    'use strict';

(()=> {
        const browserCache = {
            set(key, value) {
                const now = new Date();
                const item = {
                    value: value,
                    expiry: now.getTime() + 5 * 60 * 1000, // 5 minutes from now
                };
                localStorage.setItem(key, JSON.stringify(item));
            },
            get(key) {
                const itemStr = localStorage.getItem(key);
                if (!itemStr) {
                    return null;
                }
                const item = JSON.parse(itemStr);
                const now = new Date();
                if (now.getTime() > item.expiry) {
                    localStorage.removeItem(key);
                    return null;
                }
                return item.value;
            }
        };

window._amXSearchConfigFetcher = null;

window.amXsearchAutocompleteComponent = () => {
            const INITIAL_QUERY_CACHE_KEY = 'x.InitialQuery';
            const CONFIG_QUERY_CACHE_KEY = 'x.ConfigQuery';
            const PREV_QUERY_CACHE_KEY = 'x.PrevQuery';
            // TODO: Possible it will needs to change after the configurations are added to Admin
            const HEADER_TYPE = 'b';

const cache = {};
            const dataSections = {
                products: false,
                category: false,
                page: false,
                faq: false,
                landingPage: false,
                browsingHistory: false,
                popularSearches: false,
                bestsellers: false,
                recentSearches: false,
                recentlyViewed: false,
                brand: false,
                blog: false
            };

return {
                isLoading: false,
                searchInitialized: false,
                latestQuery: '',
                productNameMaxLength: 30,
                resultPageUrl: 'https://www.animilo.fr/catalogsearch/result/?q=',
                minSearchLength: 3,
                maxSearchLength: 128,
                isDefaultSearchInput: false,
                isFullWidthSearch: false,
                searchPopupWidth: 900,
                showOverlay: false,
                config: {},
                slider: {
                    bestsellers: false,
                    recentlyViewed: false
                },
                isHorizontalView: true,
                noResultsFound: false,
                errorMessage: null,
                // sections
                sections: Object.create(dataSections),

isHyvaUiHeader() {
                  return HEADER_TYPE.length && HEADER_TYPE !== 'default';
                },

checkHyvaUiHeaderVariant(needle) {
                    return this.isHyvaUiHeader() && needle === HEADER_TYPE;
                },

dynamicLayout($el) {
                    const matchMedia = window.matchMedia('(max-width: 768px)');
                    const isHorizontalViewPopupWidth = this.searchPopupWidth < 700 && !this.isDefaultSearchInput && !this.isFullWidthSearch;

this.isHorizontalView = !matchMedia.matches ? isHorizontalViewPopupWidth  : true;
                    matchMedia.addEventListener('change', event => {
                        this.isHorizontalView = !matchMedia.matches ? isHorizontalViewPopupWidth : true;
                    })

if (!window._amXSearchConfigFetcher) {
                        window._amXSearchConfigFetcher = new Promise(async resolve => {
                            const cachedData = browserCache.get(CONFIG_QUERY_CACHE_KEY);

if (cachedData) {
                                return resolve(cachedData);
                            }

const query = `query {config: storeConfig {
            isProductReviewsBlockEnabled: amasty_xsearch_product_reviews
            isProductAddToCartBlockEnabled: amasty_xsearch_product_add_to_cart
            isRedirectToSingleProductEnabled: amasty_xsearch_product_redirect_single_product
            isFullScreenMode: amasty_xsearch_general_full_screen
            isGridView: amasty_xsearch_product_popup_display
            isShowSku: amasty_xsearch_product_show_sku
            shortDescriptionLength: amasty_xsearch_product_desc_length

customMediaUrl: secure_base_media_url

amasty_xsearch_products_title: amasty_xsearch_product_title
            amasty_xsearch_popularSearches_title: amasty_xsearch_popular_searches_title
            amasty_xsearch_browsingHistory_title: amasty_xsearch_browsing_history_title
            amasty_xsearch_recentSearches_title: amasty_xsearch_recent_searches_title
            amasty_xsearch_recentlyViewed_title: amasty_xsearch_recently_viewed_title
            amasty_xsearch_landingPage_title: amasty_xsearch_landing_page_title
            amasty_xsearch_bestsellers_position

amasty_xsearch_faq_title
            amasty_xsearch_brand_title
            amasty_xsearch_blog_title
            amasty_xsearch_category_title
            amasty_xsearch_bestsellers_title
            amasty_xsearch_page_title

amasty_xsearch_popularSearches_first_click: amasty_xsearch_popular_searches_first_click
            amasty_xsearch_browsingHistory_first_click: amasty_xsearch_browsing_history_first_click
            amasty_xsearch_recentSearches_first_click: amasty_xsearch_recent_searches_first_click

amasty_xsearch_layout_enabled
            amasty_xsearch_layout_border
            amasty_xsearch_layout_hover
            amasty_xsearch_layout_highlight
            amasty_xsearch_layout_background
            amasty_xsearch_layout_text
            amasty_xsearch_layout_hover_text
            amasty_xsearch_layout_search_button
            amasty_xsearch_layout_search_button_text
        }}`;
                            const response = await this.fetch(query, {}, CONFIG_QUERY_CACHE_KEY, false);
                            if (response.errors && response.errors.length > 0) {
                                console.error(response.errors);
                            }

browserCache.set(CONFIG_QUERY_CACHE_KEY, response);
                            resolve(response);
                        });
                    }

_amXSearchConfigFetcher.then(response => {
                        if (!response?.data?.config) {
                            return;
                        }

this.config = response.data.config;
                        this.processCustomLayoutStyles($el);
                    });

if (typeof this.searchOpen !== "undefined") {
                        this.$watch('searchOpen', val => {
                            if (!val) {
                                return;
                            }

requestAnimationFrame(() => {
                                const searchInput = document.querySelector('#search');
                                searchInput && searchInput.focus();
                            });
                        });
                    }

if (typeof this.showOverlay !== "undefined") {
                        this.$watch('showOverlay', val => {
                            if (!val) {
                                return;
                            }

this.applyHyvaUiHeaderConfig()
                        });
                    }

this.applyHeaderTypeToContainers();
                                    },

isSidebarSectionsDisabled() {
                    if (!this.isHorizontalView) {
                        return !Object.entries(this.sections).some(([key, value]) =>
                            key !== 'products' && key !== 'bestsellers' && key !== 'recentlyViewed' && value.total_count > 0
                        );
                    }
                },

showSideBar() {
                    const recentlyViewed = this.sections?.recentlyViewed;
                    return this.latestQuery.length >= 3
                        || (recentlyViewed && recentlyViewed?.items?.length);
                },

showOnFirstClick(blockName) {
                    const sectionsToCheck = [
                        'popularSearches',
                        'browsingHistory',
                        'recentSearches'
                    ];

if (!sectionsToCheck.includes(blockName)) {
                        return false;
                    }

return this.latestQuery.length < this.minSearchLength
                        && this.config[`amasty_xsearch_${blockName}_first_click`]
                        && this.sections[blockName]?.items?.length;
                },

processCustomLayoutStyles() {
                    const conf = key => this.config[`amasty_xsearch_layout_${key}`];

if (!conf("enabled")) {
                        return "";
                    }

const styles = [
                        "border",
                        "hover",
                        "highlight",
                        "background",
                        "text",
                        "hover_text",
                        'search_button',
                        'search_button_text'
                    ];

const cachedConf = styles.reduce((acc, key) => {
                        acc[key] = conf(key);
                        return acc;
                    }, {});

const getDarken = (color, amount) => {
                        const hex = parseInt(color.slice(1), 16);
                        const r = Math.min(255, Math.max(0, ((hex >> 16) & 0xff) + amount));
                        const g = Math.min(255, Math.max(0, ((hex >> 8) & 0xff) + amount));
                        const b = Math.min(255, Math.max(0, (hex & 0xff) + amount));

return `#${((r << 16) | (g << 8) | b).toString(16).padStart(6, "0")}`;
                    };

const prefix = "--amsearch-color-";
                    styles.forEach((key) => {
                        const color = cachedConf[key];

canShowSection(sectionData) {
                    return sectionData && sectionData.items && sectionData.items.length > 0;
                },

initialSectionLoad() {
                    const req = this.fetch(`query xSearchQuery {
recentlyViewed: xsearchRecentlyViewed {
            items {
                small_image {
                    label
                    url
                }
                id
                is_salable
                short_description {
                    html
                }
                name
                options_container
                rating_summary
                reviews_count
                sku
                url_key
                url_suffix
                price_range {
                    minimum_price {
                        regular_price {
                            value
                            currency
                        }
                        final_price {
                            value
                            currency
                        }
                    }
                     maximum_price {
                        regular_price {
                            value
                            currency
                        }
                        final_price {
                            value
                            currency
                        }
                    }
                }
            }
        }

browsingHistory: xsearchBrowsingHistory {
            code
            items {
              name
              url
            }
            total_count
          }
}`, {}, INITIAL_QUERY_CACHE_KEY);
                    req.then(response => {
                        if (response.errors && response.errors.length > 0) {
                            console.error(response.errors);
                        }

this.searchInitialized = true;
                        this.processResponse(response);
                    });
                },

encodeHtml(html) {
                    const txt = document.createElement('textarea');
                    txt.textContent = html;
                    return txt.innerHTML;
                },

sanitize(value) {
                    if (typeof DOMPurify === 'function') {
                        return DOMPurify.sanitize(value)
                    } else {
                        return this.encodeHtml(value)
                    }
                },

doSearch() {
                    const { searchInput } = this.$refs;
                    const { latestQuery, minSearchLength } = this;
                    const inputText = this.sanitize(searchInput.value);

if (inputText !== latestQuery && cache[PREV_QUERY_CACHE_KEY]) {
                        delete cache[PREV_QUERY_CACHE_KEY];
                    }

this.latestQuery = this.sanitize(searchInput.value);

if (inputText.length < minSearchLength) {
                        this.initialSectionLoad();
                        return;
                    }

this.noResultsFound = null;
                    this.errorMessage = null;

const query = `query xSearchQuery($inputText: String!) {products: xsearchProducts(search: $inputText) {
                code
                items {
                  __typename
                  small_image {
                    label
                    url
                  }
                  
                  id
                  is_salable
                  short_description {
                    html
                  }
                  name
                  rating_summary
                  reviews_count
                  sku
                  url_key
                  url_suffix
                  
                  price_range {
                    minimum_price {
                        regular_price {
                            value
                            currency
                        }
                        final_price {
                            value
                            currency
                        }
                    }
                    maximum_price {
                        regular_price {
                            value
                            currency
                        }
                        final_price {
                            value
                            currency
                        }
                    }
                 }
                }
                total_count
              }

browsingHistory: xsearchBrowsingHistory {
            code
            items {
              name
              url
            }
            total_count
          }

terms: xsearchRelatedTerms(search: $inputText) {
                    items {
                      count
                      name
                    }
                  }

}`;
                    const req = this.fetch(query, { inputText }, PREV_QUERY_CACHE_KEY);

req.then(response => {
                        if (response.errors && response.errors.length > 0) {
                            this.errorMessage = response.errors[0].message;
                            console.error(this.errorMessage);
                        }

this.searchInitialized = true;
                        this.processResponse(response);
                    });
                },

fetch(query, variables = {}, cacheKey = null, useLoading = true) {
                    if (cacheKey && cache[cacheKey]) {
                        return Promise.resolve(cache[cacheKey]);
                    }

if (useLoading) {
                        this.isLoading = true;
                    }

const req = fetch(`${BASE_URL}graphql`, {
                        method: 'POST',
                        headers: {
                            'Content-Type': 'application/json',
                            'Store': 'fr'
                        },
                        credentials: 'include',
                        body: JSON.stringify({query, variables}),
                    });

return req.then(response => {
                        if (!response.ok) {
                            throw new Error(`HTTP error: ${response.status}`);
                        }

const body = response.json();
                        if (cacheKey) {
                            cache[cacheKey] = body;
                        }

return body;
                    })
                    .catch(reason => {
                        console.error(reason);
                    })
                    .finally(() => {
                        this.isLoading = false;
                    });
                },

checkSearchInput() {
                    if (this.$refs.searchInput.value === '') {
                        this.clear();
                    }
                },

redirect() {
                    this.isLoading = true;
                    const { searchInput } = this.$refs;
                    const inputText = this.sanitize(searchInput.value);

const products = this.sections.products;
                    if (products && products.items.length === 1 && this.config.isRedirectToSingleProductEnabled) {
                        location.href = this.getProductUrl(products.items[0]);
                        return;
                    }

const url = 'https://www.animilo.fr/catalogsearch/result/?q=';
                    location.href = url + inputText;
                },

focusElement(element) {
                    if (element && element.nodeName === "DIV") {
                        element.focus();
                        return true;
                    }
                    return false;
                },

processResponse(response) {
                    this.updateSections(response.data);
                },

clear() {
                    const initialQueryCache = cache[INITIAL_QUERY_CACHE_KEY];
                    if (!initialQueryCache) {
                        return;
                    }

initialQueryCache.then(result => {
                        this.updateSections(result.data ?? {});
                    });
                },

closeSearch() {
                    if (this.searchOpen) {
                        this.searchOpen = false;
                    }

this.$nextTick(() => {
                        this.showOverlay = false;
                        this.searchInitialized = false;
                    })

if (this.checkHyvaUiHeaderVariant('c')) {
                        this.$refs.searchContainerDesktop.classList.remove(HEADER_TYPE + '-header-type');
                    }
                },

processItemsWithRating(value) {
                    if (value.items) {
                        value.items = value.items.map(this.getRating.bind(this));
                    }
                    return value;
                },

processSection(key, value) {
                    if (!value) {
                        return value;
                    }

let processedValue;

switch (key) {
                        case 'recentlyViewed':
                        case 'bestsellers':
                            processedValue = this.processItemsWithRating(value);
                            if (processedValue.items) {
                                processedValue.items = (processedValue.items || []).map(item => {
                                    item.isSliderItem = true;
                                    return item;
                                });
                            }
                            break;
                        case 'products':
                            processedValue = this.processItemsWithRating(value);
                            processedValue = this.processProductName(processedValue);
                            break;
                        default:
                            processedValue = value;
                    }

processedValue.title = this.config[`amasty_xsearch_${key}_title`];
                    return processedValue;
                },

updateSections(rows) {
                    if (!this.showOverlay) {
                        this.showOverlay = true;
                    }

this.isLoading = false;

this.noResultsFound = !rows.products?.total_count && this.latestQuery.length >= this.minSearchLength;
                    if (!this.noResultsFound) {
                        this.errorMessage = null;
                    }

for (const key in dataSections) {
                        const data = rows[key];
                        this.sections[key] = data?.items?.length > 0
                            ? this.processSection(key, data)
                            : {items: [], total_count: 0};
                    }

if (this.latestQuery.length >= this.minSearchLength) {
                        return;
                    }

for (const key in this.slider) {
                        const items = rows[key]?.items;

if (rows.hasOwnProperty(key) && items?.length && !this.slider[key]) {
                            this.slider[key] = this.amXsearchCarouselComponent(key, items.length);
                        }
                    }
                }
            }
        }
    })();
</script>
<script>
    'use strict';

/**
     * Carousel component for xsearch
     *
     * @param key
     * @param itemCount
     * @returns Object
     */
    function amXsearchCarouselComponent(key, itemCount) {
        return {
            itemCount,
            pageSize: 4,
            active: 0,
            slider: null,
            pageFillers: 0,
            sliderEl: false,
            smallWindowItemWidth: false,
            init($refs) {
                const sliderEl = $refs[`${key}Container`];
                if (!sliderEl || itemCount === 0) {
                    return this;
                }

if (sliderEl) {
                    if (!this.isDefaultSearchInput && !this.isFullWidthSearch) {
                        if (this.searchPopupWidth <= 900) {
                            this.smallWindowItemWidth = sliderEl.clientWidth / 3;
                        }
                        if (this.searchPopupWidth <= 700) {
                            this.smallWindowItemWidth = sliderEl.clientWidth / 2;
                        }
                        if (this.searchPopupWidth <= 500) {
                            this.smallWindowItemWidth = sliderEl.clientWidth - 30;
                        }
                    }
                }

this.sliderEl = sliderEl;
                this.recalculate();
            },
            getSlider() {
                return this.sliderEl.querySelector('.carousel-slides');
            },
            calcPageSize() {
                const slider = this.getSlider();
                if (!slider) {
                    return this;
                }

const firstSlide = slides[0];

this.itemCount = slides.length;
                this.pageSize = Math.round(slider.clientWidth / firstSlide.clientWidth);

this.pageFillers = this.pageSize * Math.ceil(this.itemCount / this.pageSize) - this.itemCount;
            },
            calcActive() {
                const slider = this.getSlider();
                if (!slider) {
                    return this;
                }

const sliderItems = Math.round(this.itemCount) + Math.round(this.pageFillers);
                const calculatedActiveSlide = Math.round(
                        Math.round(slider.scrollLeft) / (Math.round(slider.scrollWidth) / sliderItems)
                );

this.active = Math.round(calculatedActiveSlide / Math.round(this.pageSize)) * Math.round(this.pageSize);
            },
            prev() {
                this.scrollTo(this.active - this.pageSize);
            },
            next() {
                this.scrollTo(this.active + this.pageSize);
            },
            scrollTo(index) {
                const slider = this.getSlider();
                if (!slider) {
                    return this;
                }

const slideWidth = slider.scrollWidth / (this.itemCount + this.pageFillers);
                slider.scrollLeft = Math.floor(slideWidth) * index;

this.calcActive();
            },

isActive(index) {
                return index === this.active;
            },

recalculate() {
                this.calcPageSize();
                setTimeout(() => this.calcActive(), 100);
            },
            onResize() {
                this.calcPageSize();
                setTimeout(() => this.calcActive(), 100);
            }
        };
    }
</script>
<script>
    'use strict';

function amXsearchAutocompleteHyvaUIHeaderCompat() {
        const HEADER_TYPE = 'b';

return {
            applyHyvaUiHeaderConfig() {
                const searchContent = document.getElementById('search-content');

if (this.isFullWidthSearch) {
                    if (!this.isHorizontalView) {
                        if (this.checkHyvaUiHeaderVariant('b')) {
                            searchContent.style = 'max-width:none';
                            searchContent.parentNode.style = 'padding-right:0; padding-left:0;';
                        }

if (this.checkHyvaUiHeaderVariant('c')) {
                            this.$refs.searchContainerDesktop.classList.add(HEADER_TYPE + '-header-type');
                            this.$refs.searchForm.style = 'padding-right:0; padding-left:0;';
                        }
                    }

if (this.checkHyvaUiHeaderVariant('a')) {
                        searchContent.style = 'max-width: none';
                    }
                }
            },

applyHeaderTypeToContainers() {
                const searchHeader = document.getElementById('header');
                const columnMain = document.querySelector('.column.main');
                const searchContent = document.getElementById('search-content');
                const headerTypeClass = HEADER_TYPE + '-header-type';

if (searchHeader || columnMain) {
                    searchHeader.classList.add(headerTypeClass);
                    columnMain.classList.add(headerTypeClass);
                }

if (this.checkHyvaUiHeaderVariant('a')) {
                    searchContent.className = 'container';
                }
            }
        }
    }
</script>

Chargement en cours...

Bois de cerf, 9 tailles différentes fendu ou entier, friandise pour le bien être du chien

^{Les points fort des}^{bois de cerf}^{en friandise pour chien}

Extrêmement durable.
100% naturel.
Riche en minéraux indispensables.
La mastication distrait l'esprit de nos chiens.
Suppress appetite.
Faible en calories.
Graisse faible.
Facile à digérer.

Les bois de cerf constituent des produits saines et naturelles pour votre chien. Riches en minéraux comme le calcium, le phosphore et le magnésium, ils aident à renforcer les os et les dents de votre compagnon. De plus, la mastication du bois de cerf aide également à nettoyer les dents de votre chien en éliminant la plaque dentaire et en prévenant les problèmes dentaires tels que la mauvaise haleine.

()

()

Bois de cerf, 9 tailles différentes fendu ou entier, friandise pour le bien être du chien

^{Les points fort des}^{bois de cerf}^{en friandise pour chien}

Le bâton en bois de cerf est une délicieuse friandise naturelle, durable et bénéfique pour la santé de votre chien.

Avantages en tant que friandise pour compagnon à 4 pattes.

Quels types de bois de cervidés conviennent à nos animaux ?

Dimensions des bâtons entiers :

Le bâton en bois de cerf : entier ou fendu ?

À quel âge peut-on les utiliser ?

Quelles sont les étapes de préparation d’un bois de cerf pour qu’il soit prêt à être consommé par votre chien ?

La croissance des bois de cerf : comment cela se produit

Le bois de cerf en friandise, la législation et traçabilité.

Le bois de cerf et son prix :

Animilo

Ressources Utiles

Coordonnées

Frais et délai de livraison

Taille	Poids du bâton en nois	Poids du chien	Races
XS	30-50 g	2-5 kg	Bichon maltais, yorkshire terrier, spitz nain, caniche toy
S	50-75 g	4-8 kg	Bichon frisé, schnauzer nain, shetland, teckel nain
M	75-100 g	6-10 kg	Jack russel terrier, shih tzu, cavalier
L	100-125 g	8-15 kg	Cocker, Teckel, Fox terrier,
XL	125-150 g	12-20 kg	Bulldog français, staffie, border collie
2XL	150-180 g	18-27 kg	Berger australien, bulldog anglais ou continental
3XL	180-225 g	25-35 kg	Malinois, labrador, golden retriever, boxer
4XL	225-275 g	30-45 kg	Staffordshire terrier, bouvier bernois, berger allemand
5 XL	275-350 g	40-60 kg	Akita, Dogue Argentin, Cane Corso

()

()

Bois de cerf, 9 tailles différentes fendu ou entier, friandise pour le bien être du chien

Les points fort des bois de cerf en friandise pour chien

^{Les points fort des}^{bois de cerf}^{en friandise pour chien}