Initial Commit

templates/frontOffice/default/assets/src/js/thelia.js

@@ -0,0 +1,741 @@
+// Avoid `console` errors in browsers that lack a console.
+(function() {
+    var method;
+    var noop = function () {};
+    var methods = [
+        'assert', 'clear', 'count', 'debug', 'dir', 'dirxml', 'error',
+        'exception', 'group', 'groupCollapsed', 'groupEnd', 'info', 'log',
+        'markTimeline', 'profile', 'profileEnd', 'table', 'time', 'timeEnd',
+        'timeStamp', 'trace', 'warn'
+    ];
+    var length = methods.length;
+    var console = (window.console = window.console || {});
+
+    while (length--) {
+        method = methods[length];
+
+        // Only stub undefined methods.
+        if (!console[method]) {
+            console[method] = noop;
+        }
+    }
+}());
+
+
+var pseManager = (function($){
+
+    // cache dom elements
+    var manager = {};
+    var $pse = {};
+
+    function init(){
+        $pse = {
+            "id": $("#pse-id"),
+            "product": $("#product"),
+            "name": $("#pse-name"),
+            "ref": $("#pse-ref"),
+            "ean": $("#pse-ean"),
+            "availability": $("#pse-availability"),
+            "validity": $("#pse-validity"),
+            "quantity": $("#quantity"),
+            "promo": $("#pse-promo"),
+            "new": $("#pse-new"),
+            "weight": $("#pse-weight"),
+            "price": $("#pse-price"),
+            "priceOld": $("#pse-price-old"),
+            "submit": $("#pse-submit"),
+            "options": {},
+            "pseId": null,
+            "useFallback": false,
+            "fallback": $("#pse-options .pse-fallback"),
+            "thumbnails": $('#product-thumbnails')
+        };
+    }
+
+    function buildProductForm() {
+        var pse = null,
+            combinationId = null,
+            combinationValue = null,
+            combinationValueId = null,
+            combinations = null,
+            combinationName = [],
+            i;
+
+        // initialization for the first default pse
+        $pse.pseId = $pse.id.val();
+
+        if (PSE_COUNT > 1) {
+            // Use fallback method ?
+            $pse.useFallback = useFallback();
+
+            if ($pse.useFallback) {
+                $("#pse-options .option-option").remove();
+
+                for (pse in PSE){
+                    combinations = PSE[pse].combinations;
+
+                    combinationName = [];
+                    if (undefined !== combinations) {
+                        for (i = 0; i < combinations.length; i++){
+                            combinationName.push(PSE_COMBINATIONS_VALUE[combinations[i]][0]);
+                        }
+                    }
+                    $pse.fallback
+                        .append("<option value='" + pse + "'>" + combinationName.join(', ') + "</option>");
+                }
+
+                $("#pse-options .pse-fallback").on("change",function(){
+                    updateProductForm();
+                });
+
+            } else {
+                $("#pse-options .option-fallback").remove();
+
+                // get the select for options
+                $("#pse-options .pse-option").each(function(){
+                    var $option = $(this);
+                    if ( $option.data("attribute") in PSE_COMBINATIONS){
+                        $pse['options'][$option.data("attribute")] = $option; // jshint ignore:line
+                        $option.on("change", updateProductForm);
+                    } else {
+                        // not affected to this product -> remove
+                        $option.closest(".option").remove();
+                    }
+                });
+
+                // build select
+                for (combinationValueId in PSE_COMBINATIONS_VALUE) {
+                    combinationValue = PSE_COMBINATIONS_VALUE[combinationValueId];
+                    $pse.options[combinationValue[1]]
+                        .append("<option value='" + combinationValueId + "'>" + combinationValue[0] + "</option>");
+                }
+
+                setPseForm();
+            }
+        }
+    }
+
+    function setPseForm(id) {
+        var pse = null,
+            combinationValueId;
+        pse = PSE[id || $pse.pseId];
+
+        if (undefined !== pse) {
+            if ($pse.useFallback) {
+                $pse.fallbak.val(pse.id);
+            } else if (undefined !== pse) {
+                for (var i = 0; i < pse.combinations.length; i++) {
+                    combinationValueId = pse.combinations[i];
+                    $pse['options'][PSE_COMBINATIONS_VALUE[combinationValueId][1]].val(pse.combinations[i]) // jshint ignore:line
+                }
+            }
+        }
+    }
+
+    function updateProductForm() {
+        var pseId = null,
+            selection;
+
+        if (PSE_COUNT > 1) {
+            if ($pse.useFallback) {
+                pseId = $pse.fallback.val();
+            } else {
+                // get form data
+                selection = getFormSelection();
+                // get the pse
+                pseId = pseExist(selection);
+
+                if ( ! pseId ) {
+                    // not exists, revert
+                    displayNotice();
+                    setPseForm();
+                    selection = getFormSelection();
+                    pseId = pseExist(selection);
+                } else {
+                    $pse.validity.hide();
+                }
+            }
+
+            $pse.id.val(pseId).trigger('change.pse', pseId);
+            $pse.pseId = pseId;
+        }
+
+        // Update UI
+        updateProductUI();
+    }
+
+    function displayNotice() {
+        var $validity = $pse.validity;
+        $validity.stop().show('fast', function(){
+            setTimeout(function(){
+                $validity.stop().hide('fast');
+            }, 3000);
+        });
+    }
+
+    function updateProductUI() {
+        var pse = PSE[$pse.pseId],
+            name = [],
+            pseValueId,
+            i
+            ;
+
+        if (undefined !== pse) {
+
+            $pse.ref.html(pse.ref);
+            // $pse.ean.html(pse.ean);
+            // name
+            if (PSE_COUNT > 1) {
+
+                for (i = 0; i < pse.combinations.length; i++) {
+                    pseValueId = pse.combinations[i];
+                    name.push(
+                        //PSE_COMBINATIONS[PSE_COMBINATIONS_VALUE[pseValueId][1]].name +
+                        //":" +
+                        PSE_COMBINATIONS_VALUE[pseValueId][0]
+                    );
+                }
+
+                $pse.name.html(" - " + name.join(", ") + "");
+            }
+
+            // promo
+            if (pse.isPromo) {
+                $pse.product.addClass("product--is-promo");
+            } else {
+                $pse.product.removeClass("product--is-promo");
+            }
+
+            // new
+            if (pse.isNew) {
+                $pse.product.addClass("product--is-new");
+            } else {
+                $pse.product.removeClass("product--is-new");
+            }
+
+            // availability
+            if (pse.quantity > 0 || !PSE_CHECK_AVAILABILITY) {
+                setProductAvailable(true);
+
+                if (parseInt($pse.quantity.val()) > pse.quantity) {
+                    $pse.quantity.val(pse.quantity);
+                }
+                if (PSE_CHECK_AVAILABILITY) {
+                    $pse.quantity.attr("max", pse.quantity);
+                } else {
+                    $pse.quantity.attr("max", PSE_DEFAULT_AVAILABLE_STOCK);
+                    $pse.quantity.val("1");
+                }
+
+            } else {
+                setProductAvailable(false);
+            }
+
+            // price
+            if (pse.isPromo) {
+                $pse.priceOld.html(pse.price);
+                $pse.price.html(pse.promo);
+            } else {
+                $pse.priceOld.html("");
+                $pse.price.html(pse.price);
+           }
+
+            // images
+            if (pse.images.length > 0) {
+                i = 0;
+                $pse.thumbnails.find('.thumbnail').each(function() {
+                    if (jQuery.inArray($(this).data('thumbId'), pse.images) !== -1) {
+                        $(this).filter('.disabled').removeClass('disabled');
+
+                        if (i === 0) {
+                            if (!$(this).hasClass('active')) {
+                                $pse.thumbnails.find('.thumbnail.active').removeClass('active');
+                                $('.product-image > img', $(this).closest("#product-gallery")).attr('src',$(this).attr('href'));
+                                $(this).addClass('active');
+                                if ($(this).filter(":visible").length != 1) {
+                                    $pse.thumbnails.carousel('next');
+                                }
+                            }
+                            i++;
+                        }
+                    } else {
+                        $(this).not('.disabled').addClass('disabled');
+                    }
+                });
+            } else {
+                $pse.thumbnails.find('.thumbnail.disabled').removeClass('disabled');
+            }
+        }
+        else {
+            setProductAvailable(false);
+        }
+    }
+
+    function setProductAvailable(available) {
+
+        if (available) {
+            $pse.availability
+                .removeClass("out-of-stock")
+                .addClass("in-stock")
+                .attr("href", "http://schema.org/InStock");
+
+            $pse.submit.prop("disabled", false);
+        }
+        else {
+            $pse.availability.removeClass("in-stock")
+                .addClass("out-of-stock")
+                .attr("href", "http://schema.org/OutOfStock");
+
+            $pse.submit.prop("disabled", true);
+        }
+    }
+
+    function pseExist(selection) {
+        var pseId,
+            pse = null,
+            combinations,
+            i,
+            j,
+            existCombination;
+
+        for (pse in PSE){
+            pseId = pse;
+            combinations = PSE[pse].combinations;
+
+            if (undefined !== combinations) {
+                for (i = 0; i < selection.length; i++) {
+                    existCombination = false;
+                    for (j = 0; j < combinations.length; j++) {
+                        if (selection[i] == combinations[j]) {
+                            existCombination = true;
+                            break;
+                        }
+                    }
+                    if (existCombination === false) {
+                        break;
+                    }
+                }
+                if (existCombination) {
+                    return pseId;
+                }
+            }
+        }
+
+        return false;
+    }
+
+    function useFallback() {
+        var pse = null,
+            count = -1,
+            pseCount = 0,
+            combinations,
+            i;
+
+        for (pse in PSE){
+            combinations = PSE[pse].combinations;
+
+            if (undefined !== combinations) {
+                pseCount = 0;
+                for (i = 0; i < combinations.length; i++) {
+                    pseCount += PSE_COMBINATIONS_VALUE[combinations[i]][1];
+                }
+                if (count == -1) {
+                    count = pseCount;
+                } else if (count != pseCount) {
+                    return true;
+                }
+            }
+        }
+
+        return (count <= 0);
+    }
+
+    function getFormSelection() {
+        var selection = [],
+            combinationId;
+
+        for (combinationId in $pse.options){
+            selection.push($pse.options[combinationId].val());
+        }
+
+        return selection;
+    }
+
+    manager.load = function(){
+        init();
+        buildProductForm();
+        updateProductForm();
+    };
+
+    return manager;
+
+}(jQuery));
+
+
+/* JQUERY PREVENT CONFLICT */
+(function ($) {
+
+    /*  ------------------------------------------------------------------
+     callback Function ------------------------------------------------ */
+    var confirmCallback = {
+        'address.delete': function ($elm) {
+            $.post($elm.attr('href'), function (data) {
+                if (data.success) {
+                    $elm.closest('tr').remove();
+                } else {
+                    bootbox.alert(data.message);
+                }
+            });
+        }
+    };
+
+
+    /*  ------------------------------------------------------------------
+     onLoad Function ------------------------------------------------- */
+    $(document).ready(function () {
+
+        // Loader
+        var $loader = $('<div class="loader"></div>');
+        $('body').append($loader);
+
+        // Display loader if we do ajax call
+        $(document)
+            .ajaxStart(function () { $loader.show(); })
+            .ajaxStop(function () { $loader.hide(); })
+            .ajaxError(function () { $loader.hide(); });
+
+        // Check if the size of the window is appropriate for ajax
+        var doAjax = ($(window).width() > 768) ? true : false;
+
+        // Main Navigation Hover
+        $('.navbar')
+            .on('click.subnav', '[data-toggle=dropdown]', function (event) {
+                if ($(this).parent().hasClass('open') && $(this).is(event.target)) { return false; }
+            })
+            .on('mouseenter.subnav', '.dropdown', function () {
+                if ($(this).hasClass('open')) { return; }
+
+                $(this).addClass('open');
+            })
+            .on('mouseleave.subnav', '.dropdown', function () {
+                var $this = $(this);
+
+                if (!$this.hasClass('open')) { return; }
+
+                //This will check if an input child has focus. If no then remove class open
+                if ($this.find(":input:focus").length === 0) {
+                    $this.removeClass('open');
+                } else {
+                    $this.find(":input:focus").one('blur', function () {
+                        $this.trigger('mouseleave.subnav');
+                    });
+                }
+            });
+
+        // Tooltip
+        $('body').tooltip({
+            selector: '[data-toggle=tooltip]'
+        });
+
+        // Confirm Dialog
+        $(document).on('click.confirm', '[data-confirm]', function () {
+            var $this       = $(this),
+                href        = $this.attr('href'),
+                callback    = $this.attr('data-confirm-callback'),
+                title       = $this.attr('data-confirm') !== '' ? $this.attr('data-confirm') : 'Are you sure?';
+
+            bootbox.confirm(title, function (confirm) {
+                if (confirm) {
+                    //Check if callback and if it's a function
+                    if (callback && $.isFunction(confirmCallback[callback])) {
+                        confirmCallback[callback]($this);
+                    } else {
+                        if (href) {
+                            window.location.href = href;
+                        } else {
+                            // If forms
+                            var $form = $this.closest("form");
+                            if ($form.size() > 0) {
+                                $form.submit();
+                            }
+                        }
+                    }
+                }
+            });
+
+            return false;
+        });
+
+        // Product Quick view Dialog
+        $(document).on('click.product-quickview', '.product-quickview', function () {
+            if (doAjax) {
+                $.get(this.href,
+                    function (data) {
+                        // Hide all currently active bootbox dialogs
+                        bootbox.hideAll();
+                        // Show dialog
+                        bootbox.dialog({
+                            message : $("#product",data),
+                            onEscape: function() {
+                                bootbox.hideAll();
+                            }
+                        });
+                        window.pseManager.load();
+                    }
+                );
+                return false;
+            }
+        });
+
+        // Product AddtoCard - OnSubmit
+        if (typeof window.PSE_FORM !== "undefined"){
+            window.pseManager.load();
+        }
+
+        $(document).on('submit.form-product', '.form-product', function () {
+            if (doAjax) {
+                var url_action  = $(this).attr("action"),
+                    product_id  = $("input[name$='product_id']",this).val(),
+                    pse_id  = $("input.pse-id",this).val(),
+                    quantity  = $("#quantity",this).val();
+
+                $.ajax({type: "POST", data: $(this).serialize(), url: url_action,
+                    success: function(data){
+                        $(".cart-container").html($(data).html());
+                        // addCartMessageUrl is initialized in layout.tpl
+                        $.ajax({url:addCartMessageUrl, data:{ product_id: product_id, pse_id: pse_id, quantity: quantity },
+                            success: function (data) {
+                                // Hide all currently active bootbox dialogs
+                                bootbox.hideAll();
+                                // Show dialog
+                                bootbox.dialog({
+                                    message : data,
+                                    onEscape: function() {
+                                        bootbox.hideAll();
+                                    }
+                                });
+                            }
+                        });
+                    },
+                    error: function (e) {
+                        console.log('Error.', e);
+                    }
+                });
+                return false;
+            }
+        });
+
+
+        // Toolbar
+        var $category_products = $('#category-products');
+        var $parent = $category_products.parent();
+
+        $parent.on('click.view-mode', '[data-toggle=view]', function () {
+            if (($(this).hasClass('btn-grid') && $parent.hasClass('grid')) || ($(this).hasClass('btn-list') && $parent.hasClass('list'))) { return; }
+
+            // Add loader effect
+            $loader.show();
+            setTimeout(function () { $parent.toggleClass('grid').toggleClass('list'); $loader.hide(); }, 400);
+
+            return false;
+        });
+
+        // Login
+        var $form_login = $('#form-login');
+        $form_login.on('change.account', ':radio', function () {
+            if ($(this).val() === '0') {
+                $('#password', $form_login).val('').prop('disabled', true); // Disabled (new customer)
+            }
+            else {
+                $('#password', $form_login).prop('disabled', false); // Enabled
+            }
+        }).find(':radio:checked').trigger('change.account');
+
+        // Mini Newsletter Subscription
+        $('#form-newsletter-mini').on('submit.newsletter', function () {
+            $.ajax({
+                url: $(this).attr('action'),
+                type: $(this).attr('method'),
+                data: $(this).serialize(),
+                dataType: 'json',
+                success: function (json) {
+                    bootbox.alert(json.message);
+                },
+                error: function(jqXHR) {
+                    try {
+                        bootbox.alert($.parseJSON(jqXHR.responseText).message);
+                    } catch (err) { // if not json response
+                        bootbox.alert(jqXHR.responseText);
+                    }
+                }
+            });
+
+            return false;
+        });
+
+
+        // Forgot Password
+        /*
+         var $forgot_password = $('.forgot-password', $form_login);
+         if($forgot_password.size() > 0) {
+         $forgot_password.popover({
+         html : true,
+         title: 'Forgot Password',
+         content: function() {
+         return $('#form-forgotpassword').html();
+         }
+         }).on('click.btn-forgot', function () {
+
+         $('.btn-forgot').click(function () {
+         alert('click form');
+         return false;
+         });
+
+         $('.btn-close').click(function () {
+         $forgot_password.popover('hide');
+         });
+
+         return false;
+         });
+         }
+         */
+
+        //.Form Filters
+        $('#form-filters').each(function () {
+            var $form = $(this);
+
+            $form
+                .on('change.filter', ':checkbox', function () {
+                    $loader.show();
+                    $form.submit();
+                })
+                .find('.group-btn > .btn').addClass('sr-only');
+        });
+
+        // Product details Thumbnails
+        $(document).on('click.thumbnails', '#product-thumbnails .thumbnail', function () {
+            if ($(this).hasClass('active')) { return false; }
+
+            var $productGallery = $(this).closest("#product-gallery");
+            $('.product-image > img', $productGallery).attr('src',$(this).attr('href'));
+            $('.thumbnail', $productGallery).removeClass('active');
+            $(this).addClass('active');
+
+            return false;
+        });
+
+        // Show Carousel control if needed
+        $('#product-gallery').each(function () {
+            if ($('.item', this).size() > 1) {
+                $('#product-thumbnails', this).carousel({interval: false}).find('.carousel-control').show();
+            }
+        });
+
+        // Payment Method
+        $('#payment-method').each(function () {
+            var $label = $('label', this);
+            $label.on('change', ':radio', function ()  {
+                $label.removeClass('active');
+                $label.filter('[for="' + $(this).attr('id') + '"]').addClass('active');
+            }).filter(':has(:checked)').addClass('active');
+        });
+
+        // Apply validation
+        $('#form-contact, #form-register, #form-address').validate({
+            highlight: function (element) {
+                $(element).closest('.form-group').addClass('has-error');
+            },
+            unhighlight: function (element) {
+                $(element).closest('.form-group').removeClass('has-error');
+            },
+            errorElement: 'span',
+            errorClass: 'help-block'
+        });
+
+        // Toolbar filter
+        $('#content').on('change.toolbarfilter', '#limit-top, #sortby-top', function () {
+            window.location = $(this).val();
+        });
+
+        // Login form (login page)
+        $form_login.each(function(){
+            var $emailInput = $('input[type="email"]', $form_login),
+                $passEnable  = $('#account1', $form_login);
+
+            $emailInput.on('keypress', function() {
+                $passEnable.click();
+            });
+        });
+
+    });
+
+})(jQuery);
+
+
+// Manage Countries and States form
+(function($) {
+    $(document).ready(function(){
+
+        var addressState = (function () {
+
+            // A private function which logs any arguments
+            initialize = function( element ) {
+                var elm = {};
+
+                elm.state = $(element);
+                elm.stateId = elm.state.val();
+                elm.country = $(elm.state.data('thelia-country'));
+                elm.countryId = elm.country.val();
+                elm.block = $(elm.state.data('thelia-toggle'));
+
+                elm.states = elm.state.children().clone();
+                elm.state.children().remove();
+
+                var updateState = function updateState() {
+                    var countryId = elm.country.val(),
+                        stateId = elm.state.val(),
+                        hasStates = false;
+
+                    if (stateId !== null && stateId !== '') {
+                        elm.stateId = stateId;
+                    }
+
+                    elm.state.children().remove();
+
+                    elm.states.each(function(){
+                        var $state = $(this);
+
+                        if ($state.data("country") == countryId) {
+                            $state.appendTo(elm.state);
+                            hasStates = true;
+                        }
+                    });
+
+                    if (hasStates) {
+                        // try to select the last state
+                        elm.state.val(elm.stateId);
+                        elm.block.removeClass("hidden");
+                    } else {
+                        elm.block.addClass("hidden");
+                    }
+                };
+
+                elm.country.on('change', updateState);
+                updateState();
+            };
+
+            return {
+                init: function() {
+
+                    $("[data-thelia-state]").each(function(){
+                        initialize(this);
+                    });
+
+                }
+            };
+
+        })();
+
+        addressState.init();
+    });
+})(jQuery);

templates/frontOffice/default/assets/src/js/vendors/bootbox.js

@@ -0,0 +1,985 @@
+/**
+ * bootbox.js [v4.4.0]
+ *
+ * http://bootboxjs.com/license.txt
+ */
+
+// @see https://github.com/makeusabrew/bootbox/issues/180
+// @see https://github.com/makeusabrew/bootbox/issues/186
+(function (root, factory) {
+
+  "use strict";
+  if (typeof define === "function" && define.amd) {
+    // AMD. Register as an anonymous module.
+    define(["jquery"], factory);
+  } else if (typeof exports === "object") {
+    // Node. Does not work with strict CommonJS, but
+    // only CommonJS-like environments that support module.exports,
+    // like Node.
+    module.exports = factory(require("jquery"));
+  } else {
+    // Browser globals (root is window)
+    root.bootbox = factory(root.jQuery);
+  }
+
+}(this, function init($, undefined) {
+
+  "use strict";
+
+  // the base DOM structure needed to create a modal
+  var templates = {
+    dialog:
+      "<div class='bootbox modal' tabindex='-1' role='dialog'>" +
+        "<div class='modal-dialog'>" +
+          "<div class='modal-content'>" +
+            "<div class='modal-body'><div class='bootbox-body'></div></div>" +
+          "</div>" +
+        "</div>" +
+      "</div>",
+    header:
+      "<div class='modal-header'>" +
+        "<h4 class='modal-title'></h4>" +
+      "</div>",
+    footer:
+      "<div class='modal-footer'></div>",
+    closeButton:
+      "<button type='button' class='bootbox-close-button close' data-dismiss='modal' aria-hidden='true'>&times;</button>",
+    form:
+      "<form class='bootbox-form'></form>",
+    inputs: {
+      text:
+        "<input class='bootbox-input bootbox-input-text form-control' autocomplete=off type=text />",
+      textarea:
+        "<textarea class='bootbox-input bootbox-input-textarea form-control'></textarea>",
+      email:
+        "<input class='bootbox-input bootbox-input-email form-control' autocomplete='off' type='email' />",
+      select:
+        "<select class='bootbox-input bootbox-input-select form-control'></select>",
+      checkbox:
+        "<div class='checkbox'><label><input class='bootbox-input bootbox-input-checkbox' type='checkbox' /></label></div>",
+      date:
+        "<input class='bootbox-input bootbox-input-date form-control' autocomplete=off type='date' />",
+      time:
+        "<input class='bootbox-input bootbox-input-time form-control' autocomplete=off type='time' />",
+      number:
+        "<input class='bootbox-input bootbox-input-number form-control' autocomplete=off type='number' />",
+      password:
+        "<input class='bootbox-input bootbox-input-password form-control' autocomplete='off' type='password' />"
+    }
+  };
+
+  var defaults = {
+    // default language
+    locale: "en",
+    // show backdrop or not. Default to static so user has to interact with dialog
+    backdrop: "static",
+    // animate the modal in/out
+    animate: true,
+    // additional class string applied to the top level dialog
+    className: null,
+    // whether or not to include a close button
+    closeButton: true,
+    // show the dialog immediately by default
+    show: true,
+    // dialog container
+    container: "body"
+  };
+
+  // our public object; augmented after our private API
+  var exports = {};
+
+  /**
+   * @private
+   */
+  function _t(key) {
+    var locale = locales[defaults.locale];
+    return locale ? locale[key] : locales.en[key];
+  }
+
+  function processCallback(e, dialog, callback) {
+    e.stopPropagation();
+    e.preventDefault();
+
+    // by default we assume a callback will get rid of the dialog,
+    // although it is given the opportunity to override this
+
+    // so, if the callback can be invoked and it *explicitly returns false*
+    // then we'll set a flag to keep the dialog active...
+    var preserveDialog = $.isFunction(callback) && callback.call(dialog, e) === false;
+
+    // ... otherwise we'll bin it
+    if (!preserveDialog) {
+      dialog.modal("hide");
+    }
+  }
+
+  function getKeyLength(obj) {
+    // @TODO defer to Object.keys(x).length if available?
+    var k, t = 0;
+    for (k in obj) {
+      t ++;
+    }
+    return t;
+  }
+
+  function each(collection, iterator) {
+    var index = 0;
+    $.each(collection, function(key, value) {
+      iterator(key, value, index++);
+    });
+  }
+
+  function sanitize(options) {
+    var buttons;
+    var total;
+
+    if (typeof options !== "object") {
+      throw new Error("Please supply an object of options");
+    }
+
+    if (!options.message) {
+      throw new Error("Please specify a message");
+    }
+
+    // make sure any supplied options take precedence over defaults
+    options = $.extend({}, defaults, options);
+
+    if (!options.buttons) {
+      options.buttons = {};
+    }
+
+    buttons = options.buttons;
+
+    total = getKeyLength(buttons);
+
+    each(buttons, function(key, button, index) {
+
+      if ($.isFunction(button)) {
+        // short form, assume value is our callback. Since button
+        // isn't an object it isn't a reference either so re-assign it
+        button = buttons[key] = {
+          callback: button
+        };
+      }
+
+      // before any further checks make sure by now button is the correct type
+      if ($.type(button) !== "object") {
+        throw new Error("button with key " + key + " must be an object");
+      }
+
+      if (!button.label) {
+        // the lack of an explicit label means we'll assume the key is good enough
+        button.label = key;
+      }
+
+      if (!button.className) {
+        if (total <= 2 && index === total-1) {
+          // always add a primary to the main option in a two-button dialog
+          button.className = "btn-primary";
+        } else {
+          button.className = "btn-default";
+        }
+      }
+    });
+
+    return options;
+  }
+
+  /**
+   * map a flexible set of arguments into a single returned object
+   * if args.length is already one just return it, otherwise
+   * use the properties argument to map the unnamed args to
+   * object properties
+   * so in the latter case:
+   * mapArguments(["foo", $.noop], ["message", "callback"])
+   * -> { message: "foo", callback: $.noop }
+   */
+  function mapArguments(args, properties) {
+    var argn = args.length;
+    var options = {};
+
+    if (argn < 1 || argn > 2) {
+      throw new Error("Invalid argument length");
+    }
+
+    if (argn === 2 || typeof args[0] === "string") {
+      options[properties[0]] = args[0];
+      options[properties[1]] = args[1];
+    } else {
+      options = args[0];
+    }
+
+    return options;
+  }
+
+  /**
+   * merge a set of default dialog options with user supplied arguments
+   */
+  function mergeArguments(defaults, args, properties) {
+    return $.extend(
+      // deep merge
+      true,
+      // ensure the target is an empty, unreferenced object
+      {},
+      // the base options object for this type of dialog (often just buttons)
+      defaults,
+      // args could be an object or array; if it's an array properties will
+      // map it to a proper options object
+      mapArguments(
+        args,
+        properties
+      )
+    );
+  }
+
+  /**
+   * this entry-level method makes heavy use of composition to take a simple
+   * range of inputs and return valid options suitable for passing to bootbox.dialog
+   */
+  function mergeDialogOptions(className, labels, properties, args) {
+    //  build up a base set of dialog properties
+    var baseOptions = {
+      className: "bootbox-" + className,
+      buttons: createLabels.apply(null, labels)
+    };
+
+    // ensure the buttons properties generated, *after* merging
+    // with user args are still valid against the supplied labels
+    return validateButtons(
+      // merge the generated base properties with user supplied arguments
+      mergeArguments(
+        baseOptions,
+        args,
+        // if args.length > 1, properties specify how each arg maps to an object key
+        properties
+      ),
+      labels
+    );
+  }
+
+  /**
+   * from a given list of arguments return a suitable object of button labels
+   * all this does is normalise the given labels and translate them where possible
+   * e.g. "ok", "confirm" -> { ok: "OK, cancel: "Annuleren" }
+   */
+  function createLabels() {
+    var buttons = {};
+
+    for (var i = 0, j = arguments.length; i < j; i++) {
+      var argument = arguments[i];
+      var key = argument.toLowerCase();
+      var value = argument.toUpperCase();
+
+      buttons[key] = {
+        label: _t(value)
+      };
+    }
+
+    return buttons;
+  }
+
+  function validateButtons(options, buttons) {
+    var allowedButtons = {};
+    each(buttons, function(key, value) {
+      allowedButtons[value] = true;
+    });
+
+    each(options.buttons, function(key) {
+      if (allowedButtons[key] === undefined) {
+        throw new Error("button key " + key + " is not allowed (options are " + buttons.join("\n") + ")");
+      }
+    });
+
+    return options;
+  }
+
+  exports.alert = function() {
+    var options;
+
+    options = mergeDialogOptions("alert", ["ok"], ["message", "callback"], arguments);
+
+    if (options.callback && !$.isFunction(options.callback)) {
+      throw new Error("alert requires callback property to be a function when provided");
+    }
+
+    /**
+     * overrides
+     */
+    options.buttons.ok.callback = options.onEscape = function() {
+      if ($.isFunction(options.callback)) {
+        return options.callback.call(this);
+      }
+      return true;
+    };
+
+    return exports.dialog(options);
+  };
+
+  exports.confirm = function() {
+    var options;
+
+    options = mergeDialogOptions("confirm", ["cancel", "confirm"], ["message", "callback"], arguments);
+
+    /**
+     * overrides; undo anything the user tried to set they shouldn't have
+     */
+    options.buttons.cancel.callback = options.onEscape = function() {
+      return options.callback.call(this, false);
+    };
+
+    options.buttons.confirm.callback = function() {
+      return options.callback.call(this, true);
+    };
+
+    // confirm specific validation
+    if (!$.isFunction(options.callback)) {
+      throw new Error("confirm requires a callback");
+    }
+
+    return exports.dialog(options);
+  };
+
+  exports.prompt = function() {
+    var options;
+    var defaults;
+    var dialog;
+    var form;
+    var input;
+    var shouldShow;
+    var inputOptions;
+
+    // we have to create our form first otherwise
+    // its value is undefined when gearing up our options
+    // @TODO this could be solved by allowing message to
+    // be a function instead...
+    form = $(templates.form);
+
+    // prompt defaults are more complex than others in that
+    // users can override more defaults
+    // @TODO I don't like that prompt has to do a lot of heavy
+    // lifting which mergeDialogOptions can *almost* support already
+    // just because of 'value' and 'inputType' - can we refactor?
+    defaults = {
+      className: "bootbox-prompt",
+      buttons: createLabels("cancel", "confirm"),
+      value: "",
+      inputType: "text"
+    };
+
+    options = validateButtons(
+      mergeArguments(defaults, arguments, ["title", "callback"]),
+      ["cancel", "confirm"]
+    );
+
+    // capture the user's show value; we always set this to false before
+    // spawning the dialog to give us a chance to attach some handlers to
+    // it, but we need to make sure we respect a preference not to show it
+    shouldShow = (options.show === undefined) ? true : options.show;
+
+    /**
+     * overrides; undo anything the user tried to set they shouldn't have
+     */
+    options.message = form;
+
+    options.buttons.cancel.callback = options.onEscape = function() {
+      return options.callback.call(this, null);
+    };
+
+    options.buttons.confirm.callback = function() {
+      var value;
+
+      switch (options.inputType) {
+        case "text":
+        case "textarea":
+        case "email":
+        case "select":
+        case "date":
+        case "time":
+        case "number":
+        case "password":
+          value = input.val();
+          break;
+
+        case "checkbox":
+          var checkedItems = input.find("input:checked");
+
+          // we assume that checkboxes are always multiple,
+          // hence we default to an empty array
+          value = [];
+
+          each(checkedItems, function(_, item) {
+            value.push($(item).val());
+          });
+          break;
+      }
+
+      return options.callback.call(this, value);
+    };
+
+    options.show = false;
+
+    // prompt specific validation
+    if (!options.title) {
+      throw new Error("prompt requires a title");
+    }
+
+    if (!$.isFunction(options.callback)) {
+      throw new Error("prompt requires a callback");
+    }
+
+    if (!templates.inputs[options.inputType]) {
+      throw new Error("invalid prompt type");
+    }
+
+    // create the input based on the supplied type
+    input = $(templates.inputs[options.inputType]);
+
+    switch (options.inputType) {
+      case "text":
+      case "textarea":
+      case "email":
+      case "date":
+      case "time":
+      case "number":
+      case "password":
+        input.val(options.value);
+        break;
+
+      case "select":
+        var groups = {};
+        inputOptions = options.inputOptions || [];
+
+        if (!$.isArray(inputOptions)) {
+          throw new Error("Please pass an array of input options");
+        }
+
+        if (!inputOptions.length) {
+          throw new Error("prompt with select requires options");
+        }
+
+        each(inputOptions, function(_, option) {
+
+          // assume the element to attach to is the input...
+          var elem = input;
+
+          if (option.value === undefined || option.text === undefined) {
+            throw new Error("given options in wrong format");
+          }
+
+          // ... but override that element if this option sits in a group
+
+          if (option.group) {
+            // initialise group if necessary
+            if (!groups[option.group]) {
+              groups[option.group] = $("<optgroup/>").attr("label", option.group);
+            }
+
+            elem = groups[option.group];
+          }
+
+          elem.append("<option value='" + option.value + "'>" + option.text + "</option>");
+        });
+
+        each(groups, function(_, group) {
+          input.append(group);
+        });
+
+        // safe to set a select's value as per a normal input
+        input.val(options.value);
+        break;
+
+      case "checkbox":
+        var values   = $.isArray(options.value) ? options.value : [options.value];
+        inputOptions = options.inputOptions || [];
+
+        if (!inputOptions.length) {
+          throw new Error("prompt with checkbox requires options");
+        }
+
+        if (!inputOptions[0].value || !inputOptions[0].text) {
+          throw new Error("given options in wrong format");
+        }
+
+        // checkboxes have to nest within a containing element, so
+        // they break the rules a bit and we end up re-assigning
+        // our 'input' element to this container instead
+        input = $("<div/>");
+
+        each(inputOptions, function(_, option) {
+          var checkbox = $(templates.inputs[options.inputType]);
+
+          checkbox.find("input").attr("value", option.value);
+          checkbox.find("label").append(option.text);
+
+          // we've ensured values is an array so we can always iterate over it
+          each(values, function(_, value) {
+            if (value === option.value) {
+              checkbox.find("input").prop("checked", true);
+            }
+          });
+
+          input.append(checkbox);
+        });
+        break;
+    }
+
+    // @TODO provide an attributes option instead
+    // and simply map that as keys: vals
+    if (options.placeholder) {
+      input.attr("placeholder", options.placeholder);
+    }
+
+    if (options.pattern) {
+      input.attr("pattern", options.pattern);
+    }
+
+    if (options.maxlength) {
+      input.attr("maxlength", options.maxlength);
+    }
+
+    // now place it in our form
+    form.append(input);
+
+    form.on("submit", function(e) {
+      e.preventDefault();
+      // Fix for SammyJS (or similar JS routing library) hijacking the form post.
+      e.stopPropagation();
+      // @TODO can we actually click *the* button object instead?
+      // e.g. buttons.confirm.click() or similar
+      dialog.find(".btn-primary").click();
+    });
+
+    dialog = exports.dialog(options);
+
+    // clear the existing handler focusing the submit button...
+    dialog.off("shown.bs.modal");
+
+    // ...and replace it with one focusing our input, if possible
+    dialog.on("shown.bs.modal", function() {
+      // need the closure here since input isn't
+      // an object otherwise
+      input.focus();
+    });
+
+    if (shouldShow === true) {
+      dialog.modal("show");
+    }
+
+    return dialog;
+  };
+
+  exports.dialog = function(options) {
+    options = sanitize(options);
+
+    var dialog = $(templates.dialog);
+    var innerDialog = dialog.find(".modal-dialog");
+    var body = dialog.find(".modal-body");
+    var buttons = options.buttons;
+    var buttonStr = "";
+    var callbacks = {
+      onEscape: options.onEscape
+    };
+
+    if ($.fn.modal === undefined) {
+      throw new Error(
+        "$.fn.modal is not defined; please double check you have included " +
+        "the Bootstrap JavaScript library. See http://getbootstrap.com/javascript/ " +
+        "for more details."
+      );
+    }
+
+    each(buttons, function(key, button) {
+
+      // @TODO I don't like this string appending to itself; bit dirty. Needs reworking
+      // can we just build up button elements instead? slower but neater. Then button
+      // can just become a template too
+      buttonStr += "<button data-bb-handler='" + key + "' type='button' class='btn " + button.className + "'>" + button.label + "</button>";
+      callbacks[key] = button.callback;
+    });
+
+    body.find(".bootbox-body").html(options.message);
+
+    if (options.animate === true) {
+      dialog.addClass("fade");
+    }
+
+    if (options.className) {
+      dialog.addClass(options.className);
+    }
+
+    if (options.size === "large") {
+      innerDialog.addClass("modal-lg");
+    } else if (options.size === "small") {
+      innerDialog.addClass("modal-sm");
+    }
+
+    if (options.title) {
+      body.before(templates.header);
+    }
+
+    if (options.closeButton) {
+      var closeButton = $(templates.closeButton);
+
+      if (options.title) {
+        dialog.find(".modal-header").prepend(closeButton);
+      } else {
+        closeButton.css("margin-top", "-10px").prependTo(body);
+      }
+    }
+
+    if (options.title) {
+      dialog.find(".modal-title").html(options.title);
+    }
+
+    if (buttonStr.length) {
+      body.after(templates.footer);
+      dialog.find(".modal-footer").html(buttonStr);
+    }
+
+
+    /**
+     * Bootstrap event listeners; used handle extra
+     * setup & teardown required after the underlying
+     * modal has performed certain actions
+     */
+
+    dialog.on("hidden.bs.modal", function(e) {
+      // ensure we don't accidentally intercept hidden events triggered
+      // by children of the current dialog. We shouldn't anymore now BS
+      // namespaces its events; but still worth doing
+      if (e.target === this) {
+        dialog.remove();
+      }
+    });
+
+    /*
+    dialog.on("show.bs.modal", function() {
+      // sadly this doesn't work; show is called *just* before
+      // the backdrop is added so we'd need a setTimeout hack or
+      // otherwise... leaving in as would be nice
+      if (options.backdrop) {
+        dialog.next(".modal-backdrop").addClass("bootbox-backdrop");
+      }
+    });
+    */
+
+    dialog.on("shown.bs.modal", function() {
+      dialog.find(".btn-primary:first").focus();
+    });
+
+    /**
+     * Bootbox event listeners; experimental and may not last
+     * just an attempt to decouple some behaviours from their
+     * respective triggers
+     */
+
+    if (options.backdrop !== "static") {
+      // A boolean true/false according to the Bootstrap docs
+      // should show a dialog the user can dismiss by clicking on
+      // the background.
+      // We always only ever pass static/false to the actual
+      // $.modal function because with `true` we can't trap
+      // this event (the .modal-backdrop swallows it)
+      // However, we still want to sort of respect true
+      // and invoke the escape mechanism instead
+      dialog.on("click.dismiss.bs.modal", function(e) {
+        // @NOTE: the target varies in >= 3.3.x releases since the modal backdrop
+        // moved *inside* the outer dialog rather than *alongside* it
+        if (dialog.children(".modal-backdrop").length) {
+          e.currentTarget = dialog.children(".modal-backdrop").get(0);
+        }
+
+        if (e.target !== e.currentTarget) {
+          return;
+        }
+
+        dialog.trigger("escape.close.bb");
+      });
+    }
+
+    dialog.on("escape.close.bb", function(e) {
+      if (callbacks.onEscape) {
+        processCallback(e, dialog, callbacks.onEscape);
+      }
+    });
+
+    /**
+     * Standard jQuery event listeners; used to handle user
+     * interaction with our dialog
+     */
+
+    dialog.on("click", ".modal-footer button", function(e) {
+      var callbackKey = $(this).data("bb-handler");
+
+      processCallback(e, dialog, callbacks[callbackKey]);
+    });
+
+    dialog.on("click", ".bootbox-close-button", function(e) {
+      // onEscape might be falsy but that's fine; the fact is
+      // if the user has managed to click the close button we
+      // have to close the dialog, callback or not
+      processCallback(e, dialog, callbacks.onEscape);
+    });
+
+    dialog.on("keyup", function(e) {
+      if (e.which === 27) {
+        dialog.trigger("escape.close.bb");
+      }
+    });
+
+    // the remainder of this method simply deals with adding our
+    // dialogent to the DOM, augmenting it with Bootstrap's modal
+    // functionality and then giving the resulting object back
+    // to our caller
+
+    $(options.container).append(dialog);
+
+    dialog.modal({
+      backdrop: options.backdrop ? "static": false,
+      keyboard: false,
+      show: false
+    });
+
+    if (options.show) {
+      dialog.modal("show");
+    }
+
+    // @TODO should we return the raw element here or should
+    // we wrap it in an object on which we can expose some neater
+    // methods, e.g. var d = bootbox.alert(); d.hide(); instead
+    // of d.modal("hide");
+
+   /*
+    function BBDialog(elem) {
+      this.elem = elem;
+    }
+
+    BBDialog.prototype = {
+      hide: function() {
+        return this.elem.modal("hide");
+      },
+      show: function() {
+        return this.elem.modal("show");
+      }
+    };
+    */
+
+    return dialog;
+
+  };
+
+  exports.setDefaults = function() {
+    var values = {};
+
+    if (arguments.length === 2) {
+      // allow passing of single key/value...
+      values[arguments[0]] = arguments[1];
+    } else {
+      // ... and as an object too
+      values = arguments[0];
+    }
+
+    $.extend(defaults, values);
+  };
+
+  exports.hideAll = function() {
+    $(".bootbox").modal("hide");
+
+    return exports;
+  };
+
+
+  /**
+   * standard locales. Please add more according to ISO 639-1 standard. Multiple language variants are
+   * unlikely to be required. If this gets too large it can be split out into separate JS files.
+   */
+  var locales = {
+    bg_BG : {
+      OK      : "Ок",
+      CANCEL  : "Отказ",
+      CONFIRM : "Потвърждавам"
+    },
+    br : {
+      OK      : "OK",
+      CANCEL  : "Cancelar",
+      CONFIRM : "Sim"
+    },
+    cs : {
+      OK      : "OK",
+      CANCEL  : "Zrušit",
+      CONFIRM : "Potvrdit"
+    },
+    da : {
+      OK      : "OK",
+      CANCEL  : "Annuller",
+      CONFIRM : "Accepter"
+    },
+    de : {
+      OK      : "OK",
+      CANCEL  : "Abbrechen",
+      CONFIRM : "Akzeptieren"
+    },
+    el : {
+      OK      : "Εντάξει",
+      CANCEL  : "Ακύρωση",
+      CONFIRM : "Επιβεβαίωση"
+    },
+    en : {
+      OK      : "OK",
+      CANCEL  : "Cancel",
+      CONFIRM : "OK"
+    },
+    es : {
+      OK      : "OK",
+      CANCEL  : "Cancelar",
+      CONFIRM : "Aceptar"
+    },
+    et : {
+      OK      : "OK",
+      CANCEL  : "Katkesta",
+      CONFIRM : "OK"
+    },
+    fa : {
+      OK      : "قبول",
+      CANCEL  : "لغو",
+      CONFIRM : "تایید"
+    },
+    fi : {
+      OK      : "OK",
+      CANCEL  : "Peruuta",
+      CONFIRM : "OK"
+    },
+    fr : {
+      OK      : "OK",
+      CANCEL  : "Annuler",
+      CONFIRM : "D'accord"
+    },
+    he : {
+      OK      : "אישור",
+      CANCEL  : "ביטול",
+      CONFIRM : "אישור"
+    },
+    hu : {
+      OK      : "OK",
+      CANCEL  : "Mégsem",
+      CONFIRM : "Megerősít"
+    },
+    hr : {
+      OK      : "OK",
+      CANCEL  : "Odustani",
+      CONFIRM : "Potvrdi"
+    },
+    id : {
+      OK      : "OK",
+      CANCEL  : "Batal",
+      CONFIRM : "OK"
+    },
+    it : {
+      OK      : "OK",
+      CANCEL  : "Annulla",
+      CONFIRM : "Conferma"
+    },
+    ja : {
+      OK      : "OK",
+      CANCEL  : "キャンセル",
+      CONFIRM : "確認"
+    },
+    lt : {
+      OK      : "Gerai",
+      CANCEL  : "Atšaukti",
+      CONFIRM : "Patvirtinti"
+    },
+    lv : {
+      OK      : "Labi",
+      CANCEL  : "Atcelt",
+      CONFIRM : "Apstiprināt"
+    },
+    nl : {
+      OK      : "OK",
+      CANCEL  : "Annuleren",
+      CONFIRM : "Accepteren"
+    },
+    no : {
+      OK      : "OK",
+      CANCEL  : "Avbryt",
+      CONFIRM : "OK"
+    },
+    pl : {
+      OK      : "OK",
+      CANCEL  : "Anuluj",
+      CONFIRM : "Potwierdź"
+    },
+    pt : {
+      OK      : "OK",
+      CANCEL  : "Cancelar",
+      CONFIRM : "Confirmar"
+    },
+    ru : {
+      OK      : "OK",
+      CANCEL  : "Отмена",
+      CONFIRM : "Применить"
+    },
+    sq : {
+      OK : "OK",
+      CANCEL : "Anulo",
+      CONFIRM : "Prano"
+    },
+    sv : {
+      OK      : "OK",
+      CANCEL  : "Avbryt",
+      CONFIRM : "OK"
+    },
+    th : {
+      OK      : "ตกลง",
+      CANCEL  : "ยกเลิก",
+      CONFIRM : "ยืนยัน"
+    },
+    tr : {
+      OK      : "Tamam",
+      CANCEL  : "İptal",
+      CONFIRM : "Onayla"
+    },
+    zh_CN : {
+      OK      : "OK",
+      CANCEL  : "取消",
+      CONFIRM : "确认"
+    },
+    zh_TW : {
+      OK      : "OK",
+      CANCEL  : "取消",
+      CONFIRM : "確認"
+    }
+  };
+
+  exports.addLocale = function(name, values) {
+    $.each(["OK", "CANCEL", "CONFIRM"], function(_, v) {
+      if (!values[v]) {
+        throw new Error("Please supply a translation for '" + v + "'");
+      }
+    });
+
+    locales[name] = {
+      OK: values.OK,
+      CANCEL: values.CANCEL,
+      CONFIRM: values.CONFIRM
+    };
+
+    return exports;
+  };
+
+  exports.removeLocale = function(name) {
+    delete locales[name];
+
+    return exports;
+  };
+
+  exports.setLocale = function(name) {
+    return exports.setDefaults("locale", name);
+  };
+
+  exports.init = function(_$) {
+    return init(_$ || $);
+  };
+
+  return exports;
+}));

templates/frontOffice/default/assets/src/js/vendors/html5shiv.js

@@ -0,0 +1,326 @@
+/**
+* @preserve HTML5 Shiv 3.7.3 | @afarkas @jdalton @jon_neal @rem | MIT/GPL2 Licensed
+*/
+;(function(window, document) {
+/*jshint evil:true */
+  /** version */
+  var version = '3.7.3';
+
+  /** Preset options */
+  var options = window.html5 || {};
+
+  /** Used to skip problem elements */
+  var reSkip = /^<|^(?:button|map|select|textarea|object|iframe|option|optgroup)$/i;
+
+  /** Not all elements can be cloned in IE **/
+  var saveClones = /^(?:a|b|code|div|fieldset|h1|h2|h3|h4|h5|h6|i|label|li|ol|p|q|span|strong|style|table|tbody|td|th|tr|ul)$/i;
+
+  /** Detect whether the browser supports default html5 styles */
+  var supportsHtml5Styles;
+
+  /** Name of the expando, to work with multiple documents or to re-shiv one document */
+  var expando = '_html5shiv';
+
+  /** The id for the the documents expando */
+  var expanID = 0;
+
+  /** Cached data for each document */
+  var expandoData = {};
+
+  /** Detect whether the browser supports unknown elements */
+  var supportsUnknownElements;
+
+  (function() {
+    try {
+        var a = document.createElement('a');
+        a.innerHTML = '<xyz></xyz>';
+        //if the hidden property is implemented we can assume, that the browser supports basic HTML5 Styles
+        supportsHtml5Styles = ('hidden' in a);
+
+        supportsUnknownElements = a.childNodes.length == 1 || (function() {
+          // assign a false positive if unable to shiv
+          (document.createElement)('a');
+          var frag = document.createDocumentFragment();
+          return (
+            typeof frag.cloneNode == 'undefined' ||
+            typeof frag.createDocumentFragment == 'undefined' ||
+            typeof frag.createElement == 'undefined'
+          );
+        }());
+    } catch(e) {
+      // assign a false positive if detection fails => unable to shiv
+      supportsHtml5Styles = true;
+      supportsUnknownElements = true;
+    }
+
+  }());
+
+  /*--------------------------------------------------------------------------*/
+
+  /**
+   * Creates a style sheet with the given CSS text and adds it to the document.
+   * @private
+   * @param {Document} ownerDocument The document.
+   * @param {String} cssText The CSS text.
+   * @returns {StyleSheet} The style element.
+   */
+  function addStyleSheet(ownerDocument, cssText) {
+    var p = ownerDocument.createElement('p'),
+        parent = ownerDocument.getElementsByTagName('head')[0] || ownerDocument.documentElement;
+
+    p.innerHTML = 'x<style>' + cssText + '</style>';
+    return parent.insertBefore(p.lastChild, parent.firstChild);
+  }
+
+  /**
+   * Returns the value of `html5.elements` as an array.
+   * @private
+   * @returns {Array} An array of shived element node names.
+   */
+  function getElements() {
+    var elements = html5.elements;
+    return typeof elements == 'string' ? elements.split(' ') : elements;
+  }
+
+  /**
+   * Extends the built-in list of html5 elements
+   * @memberOf html5
+   * @param {String|Array} newElements whitespace separated list or array of new element names to shiv
+   * @param {Document} ownerDocument The context document.
+   */
+  function addElements(newElements, ownerDocument) {
+    var elements = html5.elements;
+    if(typeof elements != 'string'){
+      elements = elements.join(' ');
+    }
+    if(typeof newElements != 'string'){
+      newElements = newElements.join(' ');
+    }
+    html5.elements = elements +' '+ newElements;
+    shivDocument(ownerDocument);
+  }
+
+   /**
+   * Returns the data associated to the given document
+   * @private
+   * @param {Document} ownerDocument The document.
+   * @returns {Object} An object of data.
+   */
+  function getExpandoData(ownerDocument) {
+    var data = expandoData[ownerDocument[expando]];
+    if (!data) {
+        data = {};
+        expanID++;
+        ownerDocument[expando] = expanID;
+        expandoData[expanID] = data;
+    }
+    return data;
+  }
+
+  /**
+   * returns a shived element for the given nodeName and document
+   * @memberOf html5
+   * @param {String} nodeName name of the element
+   * @param {Document|DocumentFragment} ownerDocument The context document.
+   * @returns {Object} The shived element.
+   */
+  function createElement(nodeName, ownerDocument, data){
+    if (!ownerDocument) {
+        ownerDocument = document;
+    }
+    if(supportsUnknownElements){
+        return ownerDocument.createElement(nodeName);
+    }
+    if (!data) {
+        data = getExpandoData(ownerDocument);
+    }
+    var node;
+
+    if (data.cache[nodeName]) {
+        node = data.cache[nodeName].cloneNode();
+    } else if (saveClones.test(nodeName)) {
+        node = (data.cache[nodeName] = data.createElem(nodeName)).cloneNode();
+    } else {
+        node = data.createElem(nodeName);
+    }
+
+    // Avoid adding some elements to fragments in IE < 9 because
+    // * Attributes like `name` or `type` cannot be set/changed once an element
+    //   is inserted into a document/fragment
+    // * Link elements with `src` attributes that are inaccessible, as with
+    //   a 403 response, will cause the tab/window to crash
+    // * Script elements appended to fragments will execute when their `src`
+    //   or `text` property is set
+    return node.canHaveChildren && !reSkip.test(nodeName) && !node.tagUrn ? data.frag.appendChild(node) : node;
+  }
+
+  /**
+   * returns a shived DocumentFragment for the given document
+   * @memberOf html5
+   * @param {Document} ownerDocument The context document.
+   * @returns {Object} The shived DocumentFragment.
+   */
+  function createDocumentFragment(ownerDocument, data){
+    if (!ownerDocument) {
+        ownerDocument = document;
+    }
+    if(supportsUnknownElements){
+        return ownerDocument.createDocumentFragment();
+    }
+    data = data || getExpandoData(ownerDocument);
+    var clone = data.frag.cloneNode(),
+        i = 0,
+        elems = getElements(),
+        l = elems.length;
+    for(;i<l;i++){
+        clone.createElement(elems[i]);
+    }
+    return clone;
+  }
+
+  /**
+   * Shivs the `createElement` and `createDocumentFragment` methods of the document.
+   * @private
+   * @param {Document|DocumentFragment} ownerDocument The document.
+   * @param {Object} data of the document.
+   */
+  function shivMethods(ownerDocument, data) {
+    if (!data.cache) {
+        data.cache = {};
+        data.createElem = ownerDocument.createElement;
+        data.createFrag = ownerDocument.createDocumentFragment;
+        data.frag = data.createFrag();
+    }
+
+
+    ownerDocument.createElement = function(nodeName) {
+      //abort shiv
+      if (!html5.shivMethods) {
+          return data.createElem(nodeName);
+      }
+      return createElement(nodeName, ownerDocument, data);
+    };
+
+    ownerDocument.createDocumentFragment = Function('h,f', 'return function(){' +
+      'var n=f.cloneNode(),c=n.createElement;' +
+      'h.shivMethods&&(' +
+        // unroll the `createElement` calls
+        getElements().join().replace(/[\w\-:]+/g, function(nodeName) {
+          data.createElem(nodeName);
+          data.frag.createElement(nodeName);
+          return 'c("' + nodeName + '")';
+        }) +
+      ');return n}'
+    )(html5, data.frag);
+  }
+
+  /*--------------------------------------------------------------------------*/
+
+  /**
+   * Shivs the given document.
+   * @memberOf html5
+   * @param {Document} ownerDocument The document to shiv.
+   * @returns {Document} The shived document.
+   */
+  function shivDocument(ownerDocument) {
+    if (!ownerDocument) {
+        ownerDocument = document;
+    }
+    var data = getExpandoData(ownerDocument);
+
+    if (html5.shivCSS && !supportsHtml5Styles && !data.hasCSS) {
+      data.hasCSS = !!addStyleSheet(ownerDocument,
+        // corrects block display not defined in IE6/7/8/9
+        'article,aside,dialog,figcaption,figure,footer,header,hgroup,main,nav,section{display:block}' +
+        // adds styling not present in IE6/7/8/9
+        'mark{background:#FF0;color:#000}' +
+        // hides non-rendered elements
+        'template{display:none}'
+      );
+    }
+    if (!supportsUnknownElements) {
+      shivMethods(ownerDocument, data);
+    }
+    return ownerDocument;
+  }
+
+  /*--------------------------------------------------------------------------*/
+
+  /**
+   * The `html5` object is exposed so that more elements can be shived and
+   * existing shiving can be detected on iframes.
+   * @type Object
+   * @example
+   *
+   * // options can be changed before the script is included
+   * html5 = { 'elements': 'mark section', 'shivCSS': false, 'shivMethods': false };
+   */
+  var html5 = {
+
+    /**
+     * An array or space separated string of node names of the elements to shiv.
+     * @memberOf html5
+     * @type Array|String
+     */
+    'elements': options.elements || 'abbr article aside audio bdi canvas data datalist details dialog figcaption figure footer header hgroup main mark meter nav output picture progress section summary template time video',
+
+    /**
+     * current version of html5shiv
+     */
+    'version': version,
+
+    /**
+     * A flag to indicate that the HTML5 style sheet should be inserted.
+     * @memberOf html5
+     * @type Boolean
+     */
+    'shivCSS': (options.shivCSS !== false),
+
+    /**
+     * Is equal to true if a browser supports creating unknown/HTML5 elements
+     * @memberOf html5
+     * @type boolean
+     */
+    'supportsUnknownElements': supportsUnknownElements,
+
+    /**
+     * A flag to indicate that the document's `createElement` and `createDocumentFragment`
+     * methods should be overwritten.
+     * @memberOf html5
+     * @type Boolean
+     */
+    'shivMethods': (options.shivMethods !== false),
+
+    /**
+     * A string to describe the type of `html5` object ("default" or "default print").
+     * @memberOf html5
+     * @type String
+     */
+    'type': 'default',
+
+    // shivs the document according to the specified `html5` object options
+    'shivDocument': shivDocument,
+
+    //creates a shived element
+    createElement: createElement,
+
+    //creates a shived documentFragment
+    createDocumentFragment: createDocumentFragment,
+
+    //extends list of elements
+    addElements: addElements
+  };
+
+  /*--------------------------------------------------------------------------*/
+
+  // expose html5
+  window.html5 = html5;
+
+  // shiv the document
+  shivDocument(document);
+
+  if(typeof module == 'object' && module.exports){
+    module.exports = html5;
+  }
+
+}(typeof window !== "undefined" ? window : this, document));

templates/frontOffice/default/assets/src/js/vendors/respond.js

@@ -0,0 +1,341 @@
+/*! Respond.js v1.4.0: min/max-width media query polyfill. (c) Scott Jehl. MIT Lic. j.mp/respondjs  */
+(function( w ){
+
+	"use strict";
+
+	//exposed namespace
+	var respond = {};
+	w.respond = respond;
+
+	//define update even in native-mq-supporting browsers, to avoid errors
+	respond.update = function(){};
+
+	//define ajax obj
+	var requestQueue = [],
+		xmlHttp = (function() {
+			var xmlhttpmethod = false;
+			try {
+				xmlhttpmethod = new w.XMLHttpRequest();
+			}
+			catch( e ){
+				xmlhttpmethod = new w.ActiveXObject( "Microsoft.XMLHTTP" );
+			}
+			return function(){
+				return xmlhttpmethod;
+			};
+		})(),
+
+		//tweaked Ajax functions from Quirksmode
+		ajax = function( url, callback ) {
+			var req = xmlHttp();
+			if (!req){
+				return;
+			}
+			req.open( "GET", url, true );
+			req.onreadystatechange = function () {
+				if ( req.readyState !== 4 || req.status !== 200 && req.status !== 304 ){
+					return;
+				}
+				callback( req.responseText );
+			};
+			if ( req.readyState === 4 ){
+				return;
+			}
+			req.send( null );
+		};
+
+	//expose for testing
+	respond.ajax = ajax;
+	respond.queue = requestQueue;
+
+	// expose for testing
+	respond.regex = {
+		media: /@media[^\{]+\{([^\{\}]*\{[^\}\{]*\})+/gi,
+		keyframes: /@(?:\-(?:o|moz|webkit)\-)?keyframes[^\{]+\{(?:[^\{\}]*\{[^\}\{]*\})+[^\}]*\}/gi,
+		urls: /(url\()['"]?([^\/\)'"][^:\)'"]+)['"]?(\))/g,
+		findStyles: /@media *([^\{]+)\{([\S\s]+?)$/,
+		only: /(only\s+)?([a-zA-Z]+)\s?/,
+		minw: /\([\s]*min\-width\s*:[\s]*([\s]*[0-9\.]+)(px|em)[\s]*\)/,
+		maxw: /\([\s]*max\-width\s*:[\s]*([\s]*[0-9\.]+)(px|em)[\s]*\)/
+	};
+
+	//expose media query support flag for external use
+	respond.mediaQueriesSupported = w.matchMedia && w.matchMedia( "only all" ) !== null && w.matchMedia( "only all" ).matches;
+
+	//if media queries are supported, exit here
+	if( respond.mediaQueriesSupported ){
+		return;
+	}
+
+	//define vars
+	var doc = w.document,
+		docElem = doc.documentElement,
+		mediastyles = [],
+		rules = [],
+		appendedEls = [],
+		parsedSheets = {},
+		resizeThrottle = 30,
+		head = doc.getElementsByTagName( "head" )[0] || docElem,
+		base = doc.getElementsByTagName( "base" )[0],
+		links = head.getElementsByTagName( "link" ),
+
+		lastCall,
+		resizeDefer,
+
+		//cached container for 1em value, populated the first time it's needed
+		eminpx,
+
+		// returns the value of 1em in pixels
+		getEmValue = function() {
+			var ret,
+				div = doc.createElement('div'),
+				body = doc.body,
+				originalHTMLFontSize = docElem.style.fontSize,
+				originalBodyFontSize = body && body.style.fontSize,
+				fakeUsed = false;
+
+			div.style.cssText = "position:absolute;font-size:1em;width:1em";
+
+			if( !body ){
+				body = fakeUsed = doc.createElement( "body" );
+				body.style.background = "none";
+			}
+
+			// 1em in a media query is the value of the default font size of the browser
+			// reset docElem and body to ensure the correct value is returned
+			docElem.style.fontSize = "100%";
+			body.style.fontSize = "100%";
+
+			body.appendChild( div );
+
+			if( fakeUsed ){
+				docElem.insertBefore( body, docElem.firstChild );
+			}
+
+			ret = div.offsetWidth;
+
+			if( fakeUsed ){
+				docElem.removeChild( body );
+			}
+			else {
+				body.removeChild( div );
+			}
+
+			// restore the original values
+			docElem.style.fontSize = originalHTMLFontSize;
+			if( originalBodyFontSize ) {
+				body.style.fontSize = originalBodyFontSize;
+			}
+
+
+			//also update eminpx before returning
+			ret = eminpx = parseFloat(ret);
+
+			return ret;
+		},
+
+		//enable/disable styles
+		applyMedia = function( fromResize ){
+			var name = "clientWidth",
+				docElemProp = docElem[ name ],
+				currWidth = doc.compatMode === "CSS1Compat" && docElemProp || doc.body[ name ] || docElemProp,
+				styleBlocks	= {},
+				lastLink = links[ links.length-1 ],
+				now = (new Date()).getTime();
+
+			//throttle resize calls
+			if( fromResize && lastCall && now - lastCall < resizeThrottle ){
+				w.clearTimeout( resizeDefer );
+				resizeDefer = w.setTimeout( applyMedia, resizeThrottle );
+				return;
+			}
+			else {
+				lastCall = now;
+			}
+
+			for( var i in mediastyles ){
+				if( mediastyles.hasOwnProperty( i ) ){
+					var thisstyle = mediastyles[ i ],
+						min = thisstyle.minw,
+						max = thisstyle.maxw,
+						minnull = min === null,
+						maxnull = max === null,
+						em = "em";
+
+					if( !!min ){
+						min = parseFloat( min ) * ( min.indexOf( em ) > -1 ? ( eminpx || getEmValue() ) : 1 );
+					}
+					if( !!max ){
+						max = parseFloat( max ) * ( max.indexOf( em ) > -1 ? ( eminpx || getEmValue() ) : 1 );
+					}
+
+					// if there's no media query at all (the () part), or min or max is not null, and if either is present, they're true
+					if( !thisstyle.hasquery || ( !minnull || !maxnull ) && ( minnull || currWidth >= min ) && ( maxnull || currWidth <= max ) ){
+						if( !styleBlocks[ thisstyle.media ] ){
+							styleBlocks[ thisstyle.media ] = [];
+						}
+						styleBlocks[ thisstyle.media ].push( rules[ thisstyle.rules ] );
+					}
+				}
+			}
+
+			//remove any existing respond style element(s)
+			for( var j in appendedEls ){
+				if( appendedEls.hasOwnProperty( j ) ){
+					if( appendedEls[ j ] && appendedEls[ j ].parentNode === head ){
+						head.removeChild( appendedEls[ j ] );
+					}
+				}
+			}
+			appendedEls.length = 0;
+
+			//inject active styles, grouped by media type
+			for( var k in styleBlocks ){
+				if( styleBlocks.hasOwnProperty( k ) ){
+					var ss = doc.createElement( "style" ),
+						css = styleBlocks[ k ].join( "\n" );
+
+					ss.type = "text/css";
+					ss.media = k;
+
+					//originally, ss was appended to a documentFragment and sheets were appended in bulk.
+					//this caused crashes in IE in a number of circumstances, such as when the HTML element had a bg image set, so appending beforehand seems best. Thanks to @dvelyk for the initial research on this one!
+					head.insertBefore( ss, lastLink.nextSibling );
+
+					if ( ss.styleSheet ){
+						ss.styleSheet.cssText = css;
+					}
+					else {
+						ss.appendChild( doc.createTextNode( css ) );
+					}
+
+					//push to appendedEls to track for later removal
+					appendedEls.push( ss );
+				}
+			}
+		},
+		//find media blocks in css text, convert to style blocks
+		translate = function( styles, href, media ){
+			var qs = styles.replace( respond.regex.keyframes, '' ).match( respond.regex.media ),
+				ql = qs && qs.length || 0;
+
+			//try to get CSS path
+			href = href.substring( 0, href.lastIndexOf( "/" ) );
+
+			var repUrls = function( css ){
+					return css.replace( respond.regex.urls, "$1" + href + "$2$3" );
+				},
+				useMedia = !ql && media;
+
+			//if path exists, tack on trailing slash
+			if( href.length ){ href += "/"; }
+
+			//if no internal queries exist, but media attr does, use that
+			//note: this currently lacks support for situations where a media attr is specified on a link AND
+				//its associated stylesheet has internal CSS media queries.
+				//In those cases, the media attribute will currently be ignored.
+			if( useMedia ){
+				ql = 1;
+			}
+
+			for( var i = 0; i < ql; i++ ){
+				var fullq, thisq, eachq, eql;
+
+				//media attr
+				if( useMedia ){
+					fullq = media;
+					rules.push( repUrls( styles ) );
+				}
+				//parse for styles
+				else{
+					fullq = qs[ i ].match( respond.regex.findStyles ) && RegExp.$1;
+					rules.push( RegExp.$2 && repUrls( RegExp.$2 ) );
+				}
+
+				eachq = fullq.split( "," );
+				eql = eachq.length;
+
+				for( var j = 0; j < eql; j++ ){
+					thisq = eachq[ j ];
+					mediastyles.push( {
+						media : thisq.split( "(" )[ 0 ].match( respond.regex.only ) && RegExp.$2 || "all",
+						rules : rules.length - 1,
+						hasquery : thisq.indexOf("(") > -1,
+						minw : thisq.match( respond.regex.minw ) && parseFloat( RegExp.$1 ) + ( RegExp.$2 || "" ),
+						maxw : thisq.match( respond.regex.maxw ) && parseFloat( RegExp.$1 ) + ( RegExp.$2 || "" )
+					} );
+				}
+			}
+
+			applyMedia();
+		},
+
+		//recurse through request queue, get css text
+		makeRequests = function(){
+			if( requestQueue.length ){
+				var thisRequest = requestQueue.shift();
+
+				ajax( thisRequest.href, function( styles ){
+					translate( styles, thisRequest.href, thisRequest.media );
+					parsedSheets[ thisRequest.href ] = true;
+
+					// by wrapping recursive function call in setTimeout
+					// we prevent "Stack overflow" error in IE7
+					w.setTimeout(function(){ makeRequests(); },0);
+				} );
+			}
+		},
+
+		//loop stylesheets, send text content to translate
+		ripCSS = function(){
+
+			for( var i = 0; i < links.length; i++ ){
+				var sheet = links[ i ],
+				href = sheet.href,
+				media = sheet.media,
+				isCSS = sheet.rel && sheet.rel.toLowerCase() === "stylesheet";
+
+				//only links plz and prevent re-parsing
+				if( !!href && isCSS && !parsedSheets[ href ] ){
+					// selectivizr exposes css through the rawCssText expando
+					if (sheet.styleSheet && sheet.styleSheet.rawCssText) {
+						translate( sheet.styleSheet.rawCssText, href, media );
+						parsedSheets[ href ] = true;
+					} else {
+						if( (!/^([a-zA-Z:]*\/\/)/.test( href ) && !base) ||
+							href.replace( RegExp.$1, "" ).split( "/" )[0] === w.location.host ){
+							// IE7 doesn't handle urls that start with '//' for ajax request
+							// manually add in the protocol
+							if ( href.substring(0,2) === "//" ) { href = w.location.protocol + href; }
+							requestQueue.push( {
+								href: href,
+								media: media
+							} );
+						}
+					}
+				}
+			}
+			makeRequests();
+		};
+
+	//translate CSS
+	ripCSS();
+
+	//expose update for re-running respond later on
+	respond.update = ripCSS;
+
+	//expose getEmValue
+	respond.getEmValue = getEmValue;
+
+	//adjust on resize
+	function callMedia(){
+		applyMedia( true );
+	}
+
+	if( w.addEventListener ){
+		w.addEventListener( "resize", callMedia, false );
+	}
+	else if( w.attachEvent ){
+		w.attachEvent( "onresize", callMedia );
+	}
+})(this);