wickes-css2 2.113.0-ripple.7 → 2.113.0

package/build/js/page/bloomreach-widget/bloomreach-recommendation-carousel-widget.js

@@ -0,0 +1,318 @@
+import { createLoadingButton } from '../utils/create-loading-button';
+import { createBloomreachWidget } from './bloomreach-widget-core';
+
+const Handlebars = require('hbsfy/runtime');
+
+Handlebars.registerPartial('loader', require('../../../elements/loader.hbs'));
+Handlebars.registerPartial('button', require('../../../components/base/button.hbs'));
+Handlebars.registerPartial(
+    'bloomreach/why-not-add-card',
+    require('../../../components/bloomreach/why-not-add-card.hbs')
+);
+Handlebars.registerPartial('reviews-rating', require('../../../components/reviews-rating.hbs'));
+
+const recommendationCarouselTemplate = require('../../../components/bloomreach/why-not-add-content.hbs');
+
+const DEFAULT_EL = {
+    addToCartError: '[data-add-to-cart-error]',
+    card: '.why-not-add-card',
+    cardWrapper: '.why-not-add-card-wrapper',
+    cta: '.why-not-add-card__cta',
+    next: '[data-why-not-add-next]',
+    pagination: '[data-why-not-add-pagination]',
+    productLink: '.why-not-add-card__title',
+    prev: '[data-why-not-add-prev]',
+    root: '[data-why-not-add]',
+    slider: '[data-why-not-add-slider]',
+    productCodeAttribute: 'data-product-code',
+};
+
+export function createBloomreachRecommendationCarouselWidget(config) {
+    const state = {
+        sliders: [],
+        loadingButton: null,
+    };
+    const el = {
+        ...DEFAULT_EL,
+        widgetContainer: config.widgetContainer,
+    };
+    const addToCartEvent = config.addToCartEvent || 'addToCart';
+    let widget = null;
+
+    function getRenderedRoots($container) {
+        let $roots = $container.find(el.root);
+
+        if (config.modifier) {
+            $roots = $roots.filter(`.${config.modifier}`);
+        }
+
+        return $roots;
+    }
+
+    function removeRenderedWidget($container) {
+        getRenderedRoots($container).remove();
+    }
+
+    function normalizeProducts(payloadData) {
+        return Wick.BloomreachWidget.normalizePayload(payloadData)
+            .map(function (item) {
+                return item.baseProduct || item;
+            })
+            .filter(function (product) {
+                return config.isEligibleProduct ? config.isEligibleProduct(product) : true;
+            })
+            .slice(0, 5);
+    }
+
+    function renderWidget($container, payloadData) {
+        const products = normalizeProducts(payloadData);
+
+        if (!products.length) {
+            if (config.appendToContainer) {
+                removeRenderedWidget($container);
+            } else {
+                $container.empty().hide();
+            }
+
+            return;
+        }
+
+        const html = recommendationCarouselTemplate({
+            title: config.title,
+            modifier: config.modifier,
+            products: products.map(function (product) {
+                return {
+                    ...Wick.BloomreachWidget.getProductRenderData(product),
+                    addToCartError: config.addToCartError,
+                    showBadge: !config.hideBadge,
+                };
+            }),
+            isSingleProduct: products.length === 1,
+        });
+
+        if (config.appendToContainer) {
+            removeRenderedWidget($container);
+            $container.append(html);
+            return;
+        }
+
+        $container.html(html).show();
+    }
+
+    function destroySliders() {
+        state.sliders.forEach(function (slider) {
+            if (slider && slider.destroy) {
+                slider.destroy(true, true);
+            }
+        });
+
+        state.sliders = [];
+    }
+
+    function initSliders($root) {
+        destroySliders();
+
+        $root.find(el.slider).each(function () {
+            const sliderEl = this;
+            const $slider = $(sliderEl);
+            const $widget = $slider.closest(el.root);
+            const slidesCount = $slider.find('.swiper-slide').length;
+
+            if (slidesCount <= 1) {
+                return;
+            }
+
+            const slider = new Swiper(sliderEl, {
+                roundLengths: true,
+                slidesPerView: 1,
+                spaceBetween: 12,
+                watchOverflow: true,
+                navigation: {
+                    nextEl: $widget.find(el.next)[0],
+                    prevEl: $widget.find(el.prev)[0],
+                    disabledClass: 'why-not-add__arrow--disabled',
+                },
+                pagination: {
+                    el: $widget.find(el.pagination)[0],
+                    clickable: true,
+                    renderBullet(index, className) {
+                        return `<button class="${className}" type="button" aria-label="Go to slide ${
+                            index + 1
+                        }"></button>`;
+                    },
+                    bulletClass: 'why-not-add__pagination-item',
+                    bulletActiveClass: 'why-not-add__pagination-item--active',
+                },
+            });
+
+            state.sliders.push(slider);
+        });
+    }
+
+    function setCardAdded($card) {
+        const $button = $card.find(el.cta);
+
+        $card.removeClass('why-not-add-card--failed').addClass('why-not-add-card--added');
+        $card.find('.why-not-add-card__error').addClass('d-none');
+
+        $button.prop('disabled', true).attr('aria-label', 'Added to basket');
+        $button.find('.loading-button__text').addClass('d-none');
+        $button.find('.button__icon--success').removeClass('d-none');
+    }
+
+    function setCardFailed($card, messageText) {
+        const $button = $card.find(el.cta);
+        const errorText = messageText || config.addToCartError;
+
+        $card.removeClass('why-not-add-card--added').addClass('why-not-add-card--failed');
+
+        $button
+            .prop('disabled', true)
+            .attr('aria-label', errorText || 'Product has not been added to basket');
+
+        if (errorText) {
+            $card.find(el.addToCartError).text(errorText);
+        }
+
+        $card.find('.why-not-add-card__error').removeClass('d-none');
+    }
+
+    function handleAddToCartResponse($card, response) {
+        const messageType = response && response.messageType;
+        const isSuccess = !messageType || messageType === 'success';
+
+        if (isSuccess) {
+            if (config.disableAfterSuccess) {
+                setCardAdded($card);
+            }
+
+            return;
+        }
+
+        if (config.disableAfterFailure) {
+            setCardFailed($card, response && response.messageText);
+        }
+    }
+
+    function getAddToCartPayload(productCode) {
+        const payload = { productCode };
+
+        if (config.doNotShowAddedProductPopup) {
+            payload.doNotShowAddedProductPopup = true;
+        }
+
+        return payload;
+    }
+
+    function bindProductTracking($root) {
+        $root.off(`click.${config.namespace}Tracking`, el.productLink);
+        $root.on(`click.${config.namespace}Tracking`, el.productLink, function (event) {
+            const productCode = $(event.currentTarget)
+                .closest(el.card)
+                .attr(el.productCodeAttribute);
+
+            widget.tracking.trackClick(productCode);
+        });
+    }
+
+    function bindAddToCart($root) {
+        $root.off(`click.${config.namespace}`, el.cta);
+        $root.on(`click.${config.namespace}`, el.cta, function (event) {
+            event.preventDefault();
+
+            const $button = $(event.currentTarget);
+            const $card = $button.closest(el.cardWrapper);
+            const productCode = $card.find(el.card).attr(el.productCodeAttribute);
+
+            if (
+                !productCode ||
+                $button.prop('disabled') ||
+                state.loadingButton.isLoading($button)
+            ) {
+                return;
+            }
+
+            widget.tracking.trackAddToCart([
+                {
+                    item_id: productCode,
+                    sku: productCode,
+                },
+            ]);
+
+            state.loadingButton.start($button);
+
+            Wick.BloomreachWidget.dispatchWidgetEvent(
+                addToCartEvent,
+                getAddToCartPayload(productCode)
+            )
+                .then(function (response) {
+                    state.loadingButton.stop($button);
+
+                    if (config.doNotShowAddedProductPopup) {
+                        handleAddToCartResponse($card, response);
+                        return;
+                    }
+
+                    if (Wick.MiniBasketSliderFE) {
+                        Wick.MiniBasketSliderFE.isMiniBasketLoaded = false;
+                    }
+                })
+                .catch(function (error) {
+                    state.loadingButton.stop($button);
+
+                    if (config.disableAfterFailure) {
+                        setCardFailed($card, error && (error.messageText || error.message));
+                    }
+                });
+        });
+    }
+
+    function bindVatToggle() {
+        if (Wick.BloomreachWidget.bindVatToggle) {
+            Wick.BloomreachWidget.bindVatToggle(`${config.namespace}VatToggle`);
+        }
+    }
+
+    function initRenderedWidget($container) {
+        const $root = getRenderedRoots($container).last();
+
+        if (!$root.length) {
+            return;
+        }
+
+        if (!state.loadingButton) {
+            state.loadingButton = createLoadingButton({
+                text: Wick.BloomreachWidget.el.loadingButtonText,
+                loader: Wick.BloomreachWidget.el.loadingButtonLoader,
+            });
+        }
+
+        Wick.BloomreachWidget.drawRating($root);
+        initSliders($root);
+        bindProductTracking($root);
+        bindAddToCart($root);
+        bindVatToggle();
+        Wick.BloomreachWidget.reapplyVatDisplay();
+    }
+
+    widget = createBloomreachWidget({
+        el,
+        hide($containers) {
+            if (config.appendToContainer) {
+                $containers.each(function () {
+                    removeRenderedWidget($(this));
+                });
+                return;
+            }
+
+            $containers.empty().hide();
+        },
+        renderWidget,
+        initRenderedWidget,
+        getViewTargets($containers) {
+            return [$containers.find(el.productLink).get(0), $containers.find(el.cta).get(0)];
+        },
+    });
+
+    return widget;
+}

package/build/js/page/bloomreach-widget/bloomreach-widget-core.js

@@ -0,0 +1,370 @@
+import { isApp } from '../utils/helpers';
+import { createBloomreachWidgetTracking } from './bloomreach-widget-tracking';
+
+var Wick = window.Wick || {};
+
+import { createEvent } from '../utils/create-event';
+
+export function createBloomreachWidget(config) {
+    const tracking = config.tracking || createBloomreachWidgetTracking();
+
+    const widget = {
+        el: config.el || {},
+        tracking,
+
+        getContainers(options = {}) {
+            if (options.container) {
+                return $(options.container);
+            }
+
+            return $(widget.el.widgetContainer);
+        },
+
+        hide(options = {}) {
+            const $containers = widget.getContainers(options);
+
+            if (config.hide) {
+                config.hide($containers, options, widget);
+                return;
+            }
+
+            $containers.empty().hide();
+        },
+
+        init(payloadData, options = {}) {
+            const $containers = widget.getContainers(options);
+
+            if (!$containers.length) {
+                return;
+            }
+
+            if (!payloadData || !Wick.BloomreachWidget.hasRecommendations(payloadData)) {
+                widget.hide(options);
+                return;
+            }
+
+            tracking.setPayload(payloadData);
+
+            if (config.setPayload) {
+                config.setPayload(payloadData, widget);
+            }
+
+            $containers.each(function () {
+                const $container = $(this);
+
+                if (config.renderWidget) {
+                    config.renderWidget($container, payloadData, widget);
+                }
+
+                if (config.initRenderedWidget) {
+                    config.initRenderedWidget($container, widget);
+                }
+            });
+
+            if (config.getViewTargets) {
+                tracking.observeView(config.getViewTargets($containers, widget));
+            }
+        },
+    };
+
+    return widget;
+}
+
+Wick.BloomreachWidget = {
+    widgets: {},
+
+    el: {
+        loadingButtonText: '.loading-button__text',
+        loadingButtonLoader: '.loading-button__loader',
+        ratingOverlay: '.rating-overlay',
+        starOverlay: '.star-overlay',
+        vatInc: '.including-vat-inherit',
+        vatExc: '.excluding-vat-inherit',
+    },
+
+    badgeColorMap: {
+        blue: '#019ee3',
+        gray: '#3e3e3e',
+        green: '#9acd32',
+        red: '#cf000f',
+        yellow: '#f7ca18',
+    },
+
+    getBadgeColor(color) {
+        if (!color) {
+            return '';
+        }
+
+        return Wick.BloomreachWidget.badgeColorMap[color] || color;
+    },
+
+    getBadge(product) {
+        if (!product) {
+            return null;
+        }
+
+        const promotion = product.potentialPromotions && product.potentialPromotions[0];
+        const promotionAttributes = promotion && promotion.customAttributes;
+
+        if (promotionAttributes && promotionAttributes.overlayText) {
+            return {
+                text: promotionAttributes.overlayText,
+                textColor: Wick.BloomreachWidget.getBadgeColor(
+                    promotionAttributes.overlayTextColor
+                ),
+                color: Wick.BloomreachWidget.getBadgeColor(
+                    promotionAttributes.overlayBackgroundColor
+                ),
+            };
+        }
+
+        if (product.badge && product.badge.text) {
+            return {
+                ...product.badge,
+                textColor: Wick.BloomreachWidget.getBadgeColor(product.badge.textColor),
+                color: Wick.BloomreachWidget.getBadgeColor(product.badge.color),
+            };
+        }
+
+        return product.badge || null;
+    },
+
+    registerWidgets(widgetList) {
+        widgetList.forEach(function ({ type, widget }) {
+            Wick.BloomreachWidget.widgets[type] = widget;
+        });
+    },
+
+    getWidget(type) {
+        return Wick.BloomreachWidget.widgets[type];
+    },
+
+    init(type, payloadData, options = {}) {
+        const widget = Wick.BloomreachWidget.getWidget(type);
+
+        if (!widget || typeof widget.init !== 'function') {
+            return;
+        }
+
+        widget.init(payloadData, options, Wick.BloomreachWidget);
+    },
+
+    normalizePayload(payloadData) {
+        if (Array.isArray(payloadData)) {
+            return payloadData;
+        }
+
+        if (payloadData && Array.isArray(payloadData.recommendedProducts)) {
+            return payloadData.recommendedProducts;
+        }
+
+        return [];
+    },
+
+    hasRecommendations(payloadData) {
+        return Wick.BloomreachWidget.normalizePayload(payloadData).length > 0;
+    },
+
+    removeBlankTargets($root) {
+        if (!isApp()) {
+            return;
+        }
+
+        $root.find('a[target="_blank"]').removeAttr('target');
+    },
+
+    getDisplayPrice(product) {
+        return product.displayPrice || product.price || {};
+    },
+
+    getDisplayPriceExcVat(product) {
+        return product.displayPriceExclusiveVat || product.priceExclusiveVat || null;
+    },
+
+    getExcVatFormattedValue(product, displayPrice) {
+        const excVat = Wick.BloomreachWidget.getDisplayPriceExcVat(product);
+
+        if (excVat && excVat.formattedValue) {
+            return excVat.formattedValue;
+        }
+
+        if (!displayPrice || typeof displayPrice.value !== 'number') {
+            return displayPrice ? displayPrice.formattedValue || '' : '';
+        }
+
+        const vatRate = displayPrice.vatRatePercentage || 20;
+
+        return Wick.BloomreachWidget.formatPrice(displayPrice.value / (1 + vatRate / 100));
+    },
+
+    getPriceValue(price) {
+        return price && typeof price.value === 'number' ? price.value : 0;
+    },
+
+    getPriceFormattedValue(price) {
+        if (!price) {
+            return '';
+        }
+
+        if (price.formattedValue) {
+            return price.formattedValue;
+        }
+
+        if (typeof price.value === 'number') {
+            return Wick.BloomreachWidget.formatPrice(price.value);
+        }
+
+        return '';
+    },
+
+    getWasPrice(product) {
+        const displayPrice = Wick.BloomreachWidget.getDisplayPrice(product);
+
+        return displayPrice && displayPrice.wasPrice ? displayPrice.wasPrice : null;
+    },
+
+    getWasPriceFormatted(product) {
+        const displayPrice = Wick.BloomreachWidget.getDisplayPrice(product);
+        const wasPrice = Wick.BloomreachWidget.getWasPrice(product);
+
+        if (wasPrice && wasPrice.formattedValue) {
+            return wasPrice.formattedValue;
+        }
+
+        if (typeof wasPrice === 'number') {
+            return Wick.BloomreachWidget.formatPrice(wasPrice);
+        }
+
+        if (wasPrice) {
+            return `${displayPrice.currencySymbol || '£'}${wasPrice}`;
+        }
+
+        return '';
+    },
+
+    getExcVatWasPrice(product) {
+        const priceExclusiveVat = product.priceExclusiveVat || null;
+        const displayPriceExclusiveVat = product.displayPriceExclusiveVat || null;
+        const wasPrice =
+            (displayPriceExclusiveVat && displayPriceExclusiveVat.wasPrice) ||
+            (priceExclusiveVat && priceExclusiveVat.wasPrice);
+
+        if (wasPrice && wasPrice.formattedValue) {
+            return wasPrice.formattedValue;
+        }
+
+        if (typeof wasPrice === 'number') {
+            return Wick.BloomreachWidget.formatPrice(wasPrice);
+        }
+
+        return wasPrice || '';
+    },
+
+    getProductImage(product, fallbackProduct) {
+        const productImages = product.images || [];
+        const fallbackImages = fallbackProduct ? fallbackProduct.images || [] : [];
+        const images = productImages.length ? productImages : fallbackImages;
+
+        return (
+            images.find(function (item) {
+                return item.format === 'product';
+            }) ||
+            images.find(function (item) {
+                return item.imageType === 'PRIMARY';
+            }) ||
+            images[0] ||
+            {}
+        );
+    },
+
+    getProductRenderData(product, options = {}) {
+        const displayPrice = Wick.BloomreachWidget.getDisplayPrice(product);
+        const displayPriceExcVat = Wick.BloomreachWidget.getDisplayPriceExcVat(product);
+        const wasPriceFormatted = Wick.BloomreachWidget.getWasPriceFormatted(product);
+        const isSwitchVat = !!(window.ACC && window.ACC.app && window.ACC.app.isVatToggleAvailable);
+        const excVatFormattedValue = options.fallbackExcVat
+            ? Wick.BloomreachWidget.getExcVatFormattedValue(product, displayPrice)
+            : Wick.BloomreachWidget.getPriceFormattedValue(displayPriceExcVat);
+
+        return {
+            ...product,
+            badge: Wick.BloomreachWidget.getBadge(product),
+            price: displayPrice,
+            image:
+                options.image ||
+                Wick.BloomreachWidget.getProductImage(product, options.fallbackProduct),
+            wasPriceFormatted,
+            'switch-vat': isSwitchVat,
+            incVatFormattedValue: Wick.BloomreachWidget.getPriceFormattedValue(displayPrice),
+            incVatValue: Wick.BloomreachWidget.getPriceValue(displayPrice),
+            excVatFormattedValue,
+            excVatValue: Wick.BloomreachWidget.getPriceValue(displayPriceExcVat),
+            incVatWasPriceFormatted: wasPriceFormatted,
+            excVatWasPriceFormatted: Wick.BloomreachWidget.getExcVatWasPrice(product),
+        };
+    },
+
+    drawRating($root) {
+        const { ratingOverlay, starOverlay } = Wick.BloomreachWidget.el;
+
+        $root.find(ratingOverlay).each(function () {
+            let rating = parseFloat($(this).attr('data-rating')) || 0;
+            const $stars = $(this).children(starOverlay);
+
+            $stars.each(function () {
+                const $star = $(this);
+
+                if (rating >= 1) {
+                    rating--;
+                } else if (rating > 0) {
+                    const width = Math.asin(2 * rating - 1) / Math.PI + 0.5;
+                    $star.css('width', width + 'rem');
+                    rating = 0;
+                } else {
+                    $star.css('width', '0rem');
+                }
+            });
+        });
+    },
+
+    dispatchWidgetEvent(eventName, payload) {
+        return new Promise(function (resolve, reject) {
+            const eventDetail = { resolve, reject };
+            const event = createEvent(eventName, payload, eventDetail);
+
+            window.dispatchEvent(event);
+        });
+    },
+
+    reapplyVatDisplay() {
+        if (!Wick.VatToggle || typeof Wick.VatToggle.isActive !== 'function') {
+            return;
+        }
+
+        const { vatInc, vatExc } = Wick.BloomreachWidget.el;
+        const hiddenClassName = Wick.VatToggle.HIDDEN_CLASS_NAME || 'd-none';
+        const isExcVatActive = Wick.VatToggle.isActive();
+
+        $(vatInc).toggleClass(hiddenClassName, isExcVatActive);
+        $(vatExc).toggleClass(hiddenClassName, !isExcVatActive);
+    },
+
+    bindVatToggle(namespace) {
+        if (!Wick.VatToggle || !Wick.VatToggle.TOGGLE_VAT_EVENT_NAME) {
+            return;
+        }
+
+        const eventName = `${Wick.VatToggle.TOGGLE_VAT_EVENT_NAME}.${namespace}`;
+
+        $(window).off(eventName).on(eventName, Wick.BloomreachWidget.reapplyVatDisplay);
+    },
+
+    formatPrice(value) {
+        return new Intl.NumberFormat('en-GB', {
+            style: 'currency',
+            currency: 'GBP',
+            minimumFractionDigits: 2,
+            maximumFractionDigits: 2,
+        }).format(value);
+    },
+};