Unminify using 1.5.323

Repo with tag: https://github.com/MediaBrowser/emby-webcomponents/tree/1.5.323

src/bower_components/emby-webcomponents/headroom/headroom.css

@@ -1,15 +1,11 @@
 .headroom {
-    -webkit-transition: -webkit-transform 140ms linear;
-    -o-transition: transform 140ms linear;
-    transition: transform 140ms linear
+    transition: transform 140ms linear;
 }
 
 .headroom--pinned {
-    -webkit-transform: none;
-    transform: none
+    transform: none;
 }
 
 .headroom--unpinned:not(.headroomDisabled) {
-    -webkit-transform: translateY(-100%);
-    transform: translateY(-100%)
+    transform: translateY(-100%);
 }

src/bower_components/emby-webcomponents/headroom/headroom.js

@@ -1,136 +1,349 @@
-define(["dom", "layoutManager", "browser", "css!./headroom"], function(dom, layoutManager, browser) {
-    "use strict";
+/*!
+ * headroom.js v0.7.0 - Give your page some headroom. Hide your header until you need it
+ * Copyright (c) 2014 Nick Williams - http://wicky.nillia.ms/headroom.js
+ * License: MIT
+ */
 
+define(['dom', 'layoutManager', 'browser', 'css!./headroom'], function (dom, layoutManager, browser) {
+
+    'use strict';
+
+    /* exported features */
+
+    var requestAnimationFrame = window.requestAnimationFrame || window.webkitRequestAnimationFrame || window.mozRequestAnimationFrame;
+
+    /**
+     * Handles debouncing of events via requestAnimationFrame
+     * @see http://www.html5rocks.com/en/tutorials/speed/animations/
+     * @param {Function} callback The callback to handle whichever event
+     */
     function Debouncer(callback) {
-        this.callback = callback, this.ticking = !1
+        this.callback = callback;
+        this.ticking = false;
     }
+    Debouncer.prototype = {
+        constructor: Debouncer,
+
+        /**
+         * dispatches the event to the supplied callback
+         * @private
+         */
+        update: function () {
+            if (this.callback) {
+                this.callback();
+            }
+            this.ticking = false;
+        },
+
+        /**
+         * Attach this as the event listeners
+         */
+        handleEvent: function () {
+            if (!this.ticking) {
+                requestAnimationFrame(this.rafCallback || (this.rafCallback = this.update.bind(this)));
+                this.ticking = true;
+            }
+        }
+    };
 
     function onHeadroomClearedExternally() {
-        this.state = null
+        this.state = null;
     }
 
+    /**
+   * UI enhancement for fixed headers.
+   * Hides header when scrolling down
+   * Shows header when scrolling up
+   * @constructor
+   * @param {DOMElement} elem the header element
+   * @param {Object} options options for the widget
+   */
     function Headroom(elems, options) {
-        options = Object.assign(Headroom.options, options || {}), this.lastKnownScrollY = 0, this.elems = elems, this.scroller = options.scroller, this.debouncer = onScroll.bind(this), this.offset = options.offset, this.initialised = !1, this.initialClass = options.initialClass, this.unPinnedClass = options.unPinnedClass, this.pinnedClass = options.pinnedClass, this.state = "clear"
+        options = Object.assign(Headroom.options, options || {});
+
+        this.lastKnownScrollY = 0;
+        this.elems = elems;
+
+        this.scroller = options.scroller;
+
+        this.debouncer = onScroll.bind(this);
+        this.offset = options.offset;
+        this.initialised = false;
+
+        this.initialClass = options.initialClass;
+        this.unPinnedClass = options.unPinnedClass;
+        this.pinnedClass = options.pinnedClass;
+
+        this.state = 'clear';
     }
 
     function onScroll() {
-        this.paused || requestAnimationFrame(this.rafCallback || (this.rafCallback = this.update.bind(this)))
-    }
-    var requestAnimationFrame = window.requestAnimationFrame || window.webkitRequestAnimationFrame || window.mozRequestAnimationFrame;
-    return Debouncer.prototype = {
-        constructor: Debouncer,
-        update: function() {
-            this.callback && this.callback(), this.ticking = !1
-        },
-        handleEvent: function() {
-            this.ticking || (requestAnimationFrame(this.rafCallback || (this.rafCallback = this.update.bind(this))), this.ticking = !0)
+
+        if (this.paused) {
+            return;
         }
-    }, Headroom.prototype = {
+
+        requestAnimationFrame(this.rafCallback || (this.rafCallback = this.update.bind(this)));
+    }
+
+    Headroom.prototype = {
         constructor: Headroom,
-        init: function() {
+
+        /**
+         * Initialises the widget
+         */
+        init: function () {
+
             if (browser.supportsCssAnimation()) {
-                for (var i = 0, length = this.elems.length; i < length; i++) this.elems[i].classList.add(this.initialClass), this.elems[i].addEventListener("clearheadroom", onHeadroomClearedExternally.bind(this));
-                this.attachEvent()
+                for (var i = 0, length = this.elems.length; i < length; i++) {
+                    this.elems[i].classList.add(this.initialClass);
+                    this.elems[i].addEventListener('clearheadroom', onHeadroomClearedExternally.bind(this));
+                }
+
+                this.attachEvent();
             }
-            return this
+
+            return this;
         },
-        add: function(elem) {
-            browser.supportsCssAnimation() && (elem.classList.add(this.initialClass), elem.addEventListener("clearheadroom", onHeadroomClearedExternally.bind(this)), this.elems.push(elem))
+
+        add: function (elem) {
+
+            if (browser.supportsCssAnimation()) {
+                elem.classList.add(this.initialClass);
+                elem.addEventListener('clearheadroom', onHeadroomClearedExternally.bind(this));
+                this.elems.push(elem);
+            }
         },
-        remove: function(elem) {
-            elem.classList.remove(this.unPinnedClass), elem.classList.remove(this.initialClass), elem.classList.remove(this.pinnedClass);
-            var i = this.elems.indexOf(elem); - 1 !== i && this.elems.splice(i, 1)
+
+        remove: function (elem) {
+
+            elem.classList.remove(this.unPinnedClass);
+            elem.classList.remove(this.initialClass);
+            elem.classList.remove(this.pinnedClass);
+
+            var i = this.elems.indexOf(elem);
+            if (i !== -1) {
+                this.elems.splice(i, 1);
+            }
         },
-        pause: function() {
-            this.paused = !0
+
+        pause: function () {
+            this.paused = true;
         },
-        resume: function() {
-            this.paused = !1
+
+        resume: function () {
+            this.paused = false;
         },
-        destroy: function() {
-            this.initialised = !1;
+
+        /**
+         * Unattaches events and removes any classes that were added
+         */
+        destroy: function () {
+
+            this.initialised = false;
+
+            for (var i = 0, length = this.elems.length; i < length; i++) {
+
+                var classList = this.elems[i].classList;
+
+                classList.remove(this.unPinnedClass);
+                classList.remove(this.initialClass);
+                classList.remove(this.pinnedClass);
+            }
+
+            var scrollEventName = this.scroller.getScrollEventName ? this.scroller.getScrollEventName() : 'scroll';
+
+            dom.removeEventListener(this.scroller, scrollEventName, this.debouncer, {
+                capture: false,
+                passive: true
+            });
+        },
+
+        /**
+         * Attaches the scroll event
+         * @private
+         */
+        attachEvent: function () {
+            if (!this.initialised) {
+                this.lastKnownScrollY = this.getScrollY();
+                this.initialised = true;
+
+                var scrollEventName = this.scroller.getScrollEventName ? this.scroller.getScrollEventName() : 'scroll';
+
+                dom.addEventListener(this.scroller, scrollEventName, this.debouncer, {
+                    capture: false,
+                    passive: true
+                });
+
+                this.update();
+            }
+        },
+
+        /**
+         * Unpins the header if it's currently pinned
+         */
+        clear: function () {
+
+            if (this.state === 'clear') {
+                return;
+            }
+
+            this.state = 'clear';
+
+            var unpinnedClass = this.unPinnedClass;
+            var pinnedClass = this.pinnedClass;
+
             for (var i = 0, length = this.elems.length; i < length; i++) {
                 var classList = this.elems[i].classList;
-                classList.remove(this.unPinnedClass), classList.remove(this.initialClass), classList.remove(this.pinnedClass)
-            }
-            var scrollEventName = this.scroller.getScrollEventName ? this.scroller.getScrollEventName() : "scroll";
-            dom.removeEventListener(this.scroller, scrollEventName, this.debouncer, {
-                capture: !1,
-                passive: !0
-            })
-        },
-        attachEvent: function() {
-            if (!this.initialised) {
-                this.lastKnownScrollY = this.getScrollY(), this.initialised = !0;
-                var scrollEventName = this.scroller.getScrollEventName ? this.scroller.getScrollEventName() : "scroll";
-                dom.addEventListener(this.scroller, scrollEventName, this.debouncer, {
-                    capture: !1,
-                    passive: !0
-                }), this.update()
+
+                classList.remove(unpinnedClass);
+                //classList.remove(pinnedClass);
             }
         },
-        clear: function() {
-            if ("clear" !== this.state) {
-                this.state = "clear";
-                for (var unpinnedClass = this.unPinnedClass, i = (this.pinnedClass, 0), length = this.elems.length; i < length; i++) {
-                    this.elems[i].classList.remove(unpinnedClass)
-                }
+
+        /**
+         * Unpins the header if it's currently pinned
+         */
+        pin: function () {
+
+            if (this.state === 'pin') {
+                return;
+            }
+
+            this.state = 'pin';
+
+            var unpinnedClass = this.unPinnedClass;
+            var pinnedClass = this.pinnedClass;
+
+            for (var i = 0, length = this.elems.length; i < length; i++) {
+                var classList = this.elems[i].classList;
+
+                classList.remove(unpinnedClass);
+                classList.add(pinnedClass);
             }
         },
-        pin: function() {
-            if ("pin" !== this.state) {
-                this.state = "pin";
-                for (var unpinnedClass = this.unPinnedClass, pinnedClass = this.pinnedClass, i = 0, length = this.elems.length; i < length; i++) {
-                    var classList = this.elems[i].classList;
-                    classList.remove(unpinnedClass), classList.add(pinnedClass)
-                }
+
+        /**
+         * Unpins the header if it's currently pinned
+         */
+        unpin: function () {
+
+            if (this.state === 'unpin') {
+                return;
+            }
+
+            this.state = 'unpin';
+
+            var unpinnedClass = this.unPinnedClass;
+            var pinnedClass = this.pinnedClass;
+
+            for (var i = 0, length = this.elems.length; i < length; i++) {
+                var classList = this.elems[i].classList;
+
+                classList.add(unpinnedClass);
+                //classList.remove(pinnedClass);
             }
         },
-        unpin: function() {
-            if ("unpin" !== this.state) {
-                this.state = "unpin";
-                for (var unpinnedClass = this.unPinnedClass, i = (this.pinnedClass, 0), length = this.elems.length; i < length; i++) {
-                    this.elems[i].classList.add(unpinnedClass)
-                }
-            }
-        },
-        getScrollY: function() {
+
+        /**
+         * Gets the Y scroll position
+         * @see https://developer.mozilla.org/en-US/docs/Web/API/Window.scrollY
+         * @return {Number} pixels the page has scrolled along the Y-axis
+         */
+        getScrollY: function () {
+
             var scroller = this.scroller;
-            if (scroller.getScrollPosition) return scroller.getScrollPosition();
+
+            if (scroller.getScrollPosition) {
+                return scroller.getScrollPosition();
+            }
+
             var pageYOffset = scroller.pageYOffset;
-            if (void 0 !== pageYOffset) return pageYOffset;
+            if (pageYOffset !== undefined) {
+                return pageYOffset;
+            }
+
             var scrollTop = scroller.scrollTop;
-            return void 0 !== scrollTop ? scrollTop : (document.documentElement || document.body).scrollTop
+            if (scrollTop !== undefined) {
+                return scrollTop;
+            }
+
+            return (document.documentElement || document.body).scrollTop;
         },
-        shouldUnpin: function(currentScrollY) {
+
+        /**
+         * determine if it is appropriate to unpin
+         * @param  {int} currentScrollY the current y scroll position
+         * @return {bool} true if should unpin, false otherwise
+         */
+        shouldUnpin: function (currentScrollY) {
             var scrollingDown = currentScrollY > this.lastKnownScrollY,
                 pastOffset = currentScrollY >= this.offset;
-            return scrollingDown && pastOffset
+
+            return scrollingDown && pastOffset;
         },
-        shouldPin: function(currentScrollY) {
+
+        /**
+         * determine if it is appropriate to pin
+         * @param  {int} currentScrollY the current y scroll position
+         * @return {bool} true if should pin, false otherwise
+         */
+        shouldPin: function (currentScrollY) {
             var scrollingUp = currentScrollY < this.lastKnownScrollY,
                 pastOffset = currentScrollY <= this.offset;
-            return scrollingUp || pastOffset
+
+            return scrollingUp || pastOffset;
         },
-        update: function() {
-            if (!this.paused) {
-                var currentScrollY = this.getScrollY(),
-                    lastKnownScrollY = this.lastKnownScrollY,
-                    isTv = layoutManager.tv;
-                if (currentScrollY <= (isTv ? 120 : 10)) this.clear();
-                else if (this.shouldUnpin(currentScrollY)) this.unpin();
-                else if (this.shouldPin(currentScrollY)) {
-                    var toleranceExceeded = Math.abs(currentScrollY - lastKnownScrollY) >= 14;
-                    currentScrollY && isTv ? this.unpin() : toleranceExceeded && this.clear()
-                }
-                this.lastKnownScrollY = currentScrollY
+
+        /**
+         * Handles updating the state of the widget
+         */
+        update: function () {
+
+            if (this.paused) {
+                return;
             }
+
+            var currentScrollY = this.getScrollY();
+
+            var lastKnownScrollY = this.lastKnownScrollY;
+
+            var isTv = layoutManager.tv;
+
+            if (currentScrollY <= (isTv ? 120 : 10)) {
+                this.clear();
+            }
+            else if (this.shouldUnpin(currentScrollY)) {
+                this.unpin();
+            }
+            else if (this.shouldPin(currentScrollY)) {
+
+                var toleranceExceeded = Math.abs(currentScrollY - lastKnownScrollY) >= 14;
+
+                if (currentScrollY && isTv) {
+                    this.unpin();
+                } else if (toleranceExceeded) {
+                    this.clear();
+                }
+            } else if (isTv) {
+                //this.clear();
+            }
+
+            this.lastKnownScrollY = currentScrollY;
         }
-    }, Headroom.options = {
+    };
+    /**
+     * Default options
+     * @type {Object}
+     */
+    Headroom.options = {
         offset: 0,
         scroller: window,
-        initialClass: "headroom",
-        unPinnedClass: "headroom--unpinned",
-        pinnedClass: "headroom--pinned"
-    }, Headroom
+        initialClass: 'headroom',
+        unPinnedClass: 'headroom--unpinned',
+        pinnedClass: 'headroom--pinned'
+    };
+
+    return Headroom;
+
 });