scala-news-reader

jquery.waypoints.js

(16877B)

 // Generated by CoffeeScript 1.6.2
 /*
 jQuery Waypoints - v2.0.2
 Copyright (c) 2011-2013 Caleb Troughton
 Dual licensed under the MIT license and GPL license.
 https://github.com/imakewebthings/jquery-waypoints/blob/master/licenses.txt
 */
 
 
 (function() {
   var __indexOf = [].indexOf || function(item) { for (var i = 0, l = this.length; i < l; i++) { if (i in this && this[i] === item) return i; } return -1; },
     __slice = [].slice;
 
   (function(root, factory) {
     if (typeof define === 'function' && define.amd) {
       return define('waypoints', ['jquery'], function($) {
         return factory($, root);
       });
     } else {
       return factory(root.jQuery, root);
     }
   })(this, function($, window) {
     var $w, Context, Waypoint, allWaypoints, contextCounter, contextKey, contexts, isTouch, jQMethods, methods, resizeEvent, scrollEvent, waypointCounter, waypointKey, wp, wps;
 
     $w = $(window);
     isTouch = __indexOf.call(window, 'ontouchstart') >= 0;
     allWaypoints = {
       horizontal: {},
       vertical: {}
     };
     contextCounter = 1;
     contexts = {};
     contextKey = 'waypoints-context-id';
     resizeEvent = 'resize.waypoints';
     scrollEvent = 'scroll.waypoints';
     waypointCounter = 1;
     waypointKey = 'waypoints-waypoint-ids';
     wp = 'waypoint';
     wps = 'waypoints';
     Context = (function() {
       function Context($element) {
         var _this = this;
 
         this.$element = $element;
         this.element = $element[0];
         this.didResize = false;
         this.didScroll = false;
         this.id = 'context' + contextCounter++;
         this.oldScroll = {
           x: $element.scrollLeft(),
           y: $element.scrollTop()
         };
         this.waypoints = {
           horizontal: {},
           vertical: {}
         };
         $element.data(contextKey, this.id);
         contexts[this.id] = this;
         $element.bind(scrollEvent, function() {
           var scrollHandler;
 
           if (!(_this.didScroll || isTouch)) {
             _this.didScroll = true;
             scrollHandler = function() {
               _this.doScroll();
               return _this.didScroll = false;
             };
             return window.setTimeout(scrollHandler, $[wps].settings.scrollThrottle);
           }
         });
         $element.bind(resizeEvent, function() {
           var resizeHandler;
 
           if (!_this.didResize) {
             _this.didResize = true;
             resizeHandler = function() {
               $[wps]('refresh');
               return _this.didResize = false;
             };
             return window.setTimeout(resizeHandler, $[wps].settings.resizeThrottle);
           }
         });
       }
 
       Context.prototype.doScroll = function() {
         var axes,
           _this = this;
 
         axes = {
           horizontal: {
             newScroll: this.$element.scrollLeft(),
             oldScroll: this.oldScroll.x,
             forward: 'right',
             backward: 'left'
           },
           vertical: {
             newScroll: this.$element.scrollTop(),
             oldScroll: this.oldScroll.y,
             forward: 'down',
             backward: 'up'
           }
         };
         if (isTouch && (!axes.vertical.oldScroll || !axes.vertical.newScroll)) {
           $[wps]('refresh');
         }
         $.each(axes, function(aKey, axis) {
           var direction, isForward, triggered;
 
           triggered = [];
           isForward = axis.newScroll > axis.oldScroll;
           direction = isForward ? axis.forward : axis.backward;
           $.each(_this.waypoints[aKey], function(wKey, waypoint) {
             var _ref, _ref1;
 
             if ((axis.oldScroll < (_ref = waypoint.offset) && _ref <= axis.newScroll)) {
               return triggered.push(waypoint);
             } else if ((axis.newScroll < (_ref1 = waypoint.offset) && _ref1 <= axis.oldScroll)) {
               return triggered.push(waypoint);
             }
           });
           triggered.sort(function(a, b) {
             return a.offset - b.offset;
           });
           if (!isForward) {
             triggered.reverse();
           }
           return $.each(triggered, function(i, waypoint) {
             if (waypoint.options.continuous || i === triggered.length - 1) {
               return waypoint.trigger([direction]);
             }
           });
         });
         return this.oldScroll = {
           x: axes.horizontal.newScroll,
           y: axes.vertical.newScroll
         };
       };
 
       Context.prototype.refresh = function() {
         var axes, cOffset, isWin,
           _this = this;
 
         isWin = $.isWindow(this.element);
         cOffset = this.$element.offset();
         this.doScroll();
         axes = {
           horizontal: {
             contextOffset: isWin ? 0 : cOffset.left,
             contextScroll: isWin ? 0 : this.oldScroll.x,
             contextDimension: this.$element.width(),
             oldScroll: this.oldScroll.x,
             forward: 'right',
             backward: 'left',
             offsetProp: 'left'
           },
           vertical: {
             contextOffset: isWin ? 0 : cOffset.top,
             contextScroll: isWin ? 0 : this.oldScroll.y,
             contextDimension: isWin ? $[wps]('viewportHeight') : this.$element.height(),
             oldScroll: this.oldScroll.y,
             forward: 'down',
             backward: 'up',
             offsetProp: 'top'
           }
         };
         return $.each(axes, function(aKey, axis) {
           return $.each(_this.waypoints[aKey], function(i, waypoint) {
             var adjustment, elementOffset, oldOffset, _ref, _ref1;
 
             adjustment = waypoint.options.offset;
             oldOffset = waypoint.offset;
             elementOffset = $.isWindow(waypoint.element) ? 0 : waypoint.$element.offset()[axis.offsetProp];
             if ($.isFunction(adjustment)) {
               adjustment = adjustment.apply(waypoint.element);
             } else if (typeof adjustment === 'string') {
               adjustment = parseFloat(adjustment);
               if (waypoint.options.offset.indexOf('%') > -1) {
                 adjustment = Math.ceil(axis.contextDimension * adjustment / 100);
               }
             }
             waypoint.offset = elementOffset - axis.contextOffset + axis.contextScroll - adjustment;
             if ((waypoint.options.onlyOnScroll && (oldOffset != null)) || !waypoint.enabled) {
               return;
             }
             if (oldOffset !== null && (oldOffset < (_ref = axis.oldScroll) && _ref <= waypoint.offset)) {
               return waypoint.trigger([axis.backward]);
             } else if (oldOffset !== null && (oldOffset > (_ref1 = axis.oldScroll) && _ref1 >= waypoint.offset)) {
               return waypoint.trigger([axis.forward]);
             } else if (oldOffset === null && axis.oldScroll >= waypoint.offset) {
               return waypoint.trigger([axis.forward]);
             }
           });
         });
       };
 
       Context.prototype.checkEmpty = function() {
         if ($.isEmptyObject(this.waypoints.horizontal) && $.isEmptyObject(this.waypoints.vertical)) {
           this.$element.unbind([resizeEvent, scrollEvent].join(' '));
           return delete contexts[this.id];
         }
       };
 
       return Context;
 
     })();
     Waypoint = (function() {
       function Waypoint($element, context, options) {
         var idList, _ref;
 
         options = $.extend({}, $.fn[wp].defaults, options);
         if (options.offset === 'bottom-in-view') {
           options.offset = function() {
             var contextHeight;
 
             contextHeight = $[wps]('viewportHeight');
             if (!$.isWindow(context.element)) {
               contextHeight = context.$element.height();
             }
             return contextHeight - $(this).outerHeight();
           };
         }
         this.$element = $element;
         this.element = $element[0];
         this.axis = options.horizontal ? 'horizontal' : 'vertical';
         this.callback = options.handler;
         this.context = context;
         this.enabled = options.enabled;
         this.id = 'waypoints' + waypointCounter++;
         this.offset = null;
         this.options = options;
         context.waypoints[this.axis][this.id] = this;
         allWaypoints[this.axis][this.id] = this;
         idList = (_ref = $element.data(waypointKey)) != null ? _ref : [];
         idList.push(this.id);
         $element.data(waypointKey, idList);
       }
 
       Waypoint.prototype.trigger = function(args) {
         if (!this.enabled) {
           return;
         }
         if (this.callback != null) {
           this.callback.apply(this.element, args);
         }
         if (this.options.triggerOnce) {
           return this.destroy();
         }
       };
 
       Waypoint.prototype.disable = function() {
         return this.enabled = false;
       };
 
       Waypoint.prototype.enable = function() {
         this.context.refresh();
         return this.enabled = true;
       };
 
       Waypoint.prototype.destroy = function() {
         delete allWaypoints[this.axis][this.id];
         delete this.context.waypoints[this.axis][this.id];
         return this.context.checkEmpty();
       };
 
       Waypoint.getWaypointsByElement = function(element) {
         var all, ids;
 
         ids = $(element).data(waypointKey);
         if (!ids) {
           return [];
         }
         all = $.extend({}, allWaypoints.horizontal, allWaypoints.vertical);
         return $.map(ids, function(id) {
           return all[id];
         });
       };
 
       return Waypoint;
 
     })();
     methods = {
       init: function(f, options) {
         var _ref;
 
         if (options == null) {
           options = {};
         }
         if ((_ref = options.handler) == null) {
           options.handler = f;
         }
         this.each(function() {
           var $this, context, contextElement, _ref1;
 
           $this = $(this);
           contextElement = (_ref1 = options.context) != null ? _ref1 : $.fn[wp].defaults.context;
           if (!$.isWindow(contextElement)) {
             contextElement = $this.closest(contextElement);
           }
           contextElement = $(contextElement);
           context = contexts[contextElement.data(contextKey)];
           if (!context) {
             context = new Context(contextElement);
           }
           return new Waypoint($this, context, options);
         });
         $[wps]('refresh');
         return this;
       },
       disable: function() {
         return methods._invoke(this, 'disable');
       },
       enable: function() {
         return methods._invoke(this, 'enable');
       },
       destroy: function() {
         return methods._invoke(this, 'destroy');
       },
       prev: function(axis, selector) {
         return methods._traverse.call(this, axis, selector, function(stack, index, waypoints) {
           if (index > 0) {
             return stack.push(waypoints[index - 1]);
           }
         });
       },
       next: function(axis, selector) {
         return methods._traverse.call(this, axis, selector, function(stack, index, waypoints) {
           if (index < waypoints.length - 1) {
             return stack.push(waypoints[index + 1]);
           }
         });
       },
       _traverse: function(axis, selector, push) {
         var stack, waypoints;
 
         if (axis == null) {
           axis = 'vertical';
         }
         if (selector == null) {
           selector = window;
         }
         waypoints = jQMethods.aggregate(selector);
         stack = [];
         this.each(function() {
           var index;
 
           index = $.inArray(this, waypoints[axis]);
           return push(stack, index, waypoints[axis]);
         });
         return this.pushStack(stack);
       },
       _invoke: function($elements, method) {
         $elements.each(function() {
           var waypoints;
 
           waypoints = Waypoint.getWaypointsByElement(this);
           return $.each(waypoints, function(i, waypoint) {
             waypoint[method]();
             return true;
           });
         });
         return this;
       }
     };
     $.fn[wp] = function() {
       var args, method;
 
       method = arguments[0], args = 2 <= arguments.length ? __slice.call(arguments, 1) : [];
       if (methods[method]) {
         return methods[method].apply(this, args);
       } else if ($.isFunction(method)) {
         return methods.init.apply(this, arguments);
       } else if ($.isPlainObject(method)) {
         return methods.init.apply(this, [null, method]);
       } else if (!method) {
         return $.error("jQuery Waypoints needs a callback function or handler option.");
       } else {
         return $.error("The " + method + " method does not exist in jQuery Waypoints.");
       }
     };
     $.fn[wp].defaults = {
       context: window,
       continuous: true,
       enabled: true,
       horizontal: false,
       offset: 0,
       triggerOnce: false
     };
     jQMethods = {
       refresh: function() {
         return $.each(contexts, function(i, context) {
           return context.refresh();
         });
       },
       viewportHeight: function() {
         var _ref;
 
         return (_ref = window.innerHeight) != null ? _ref : $w.height();
       },
       aggregate: function(contextSelector) {
         var collection, waypoints, _ref;
 
         collection = allWaypoints;
         if (contextSelector) {
           collection = (_ref = contexts[$(contextSelector).data(contextKey)]) != null ? _ref.waypoints : void 0;
         }
         if (!collection) {
           return [];
         }
         waypoints = {
           horizontal: [],
           vertical: []
         };
         $.each(waypoints, function(axis, arr) {
           $.each(collection[axis], function(key, waypoint) {
             return arr.push(waypoint);
           });
           arr.sort(function(a, b) {
             return a.offset - b.offset;
           });
           waypoints[axis] = $.map(arr, function(waypoint) {
             return waypoint.element;
           });
           return waypoints[axis] = $.unique(waypoints[axis]);
         });
         return waypoints;
       },
       above: function(contextSelector) {
         if (contextSelector == null) {
           contextSelector = window;
         }
         return jQMethods._filter(contextSelector, 'vertical', function(context, waypoint) {
           return waypoint.offset <= context.oldScroll.y;
         });
       },
       below: function(contextSelector) {
         if (contextSelector == null) {
           contextSelector = window;
         }
         return jQMethods._filter(contextSelector, 'vertical', function(context, waypoint) {
           return waypoint.offset > context.oldScroll.y;
         });
       },
       left: function(contextSelector) {
         if (contextSelector == null) {
           contextSelector = window;
         }
         return jQMethods._filter(contextSelector, 'horizontal', function(context, waypoint) {
           return waypoint.offset <= context.oldScroll.x;
         });
       },
       right: function(contextSelector) {
         if (contextSelector == null) {
           contextSelector = window;
         }
         return jQMethods._filter(contextSelector, 'horizontal', function(context, waypoint) {
           return waypoint.offset > context.oldScroll.x;
         });
       },
       enable: function() {
         return jQMethods._invoke('enable');
       },
       disable: function() {
         return jQMethods._invoke('disable');
       },
       destroy: function() {
         return jQMethods._invoke('destroy');
       },
       extendFn: function(methodName, f) {
         return methods[methodName] = f;
       },
       _invoke: function(method) {
         var waypoints;
 
         waypoints = $.extend({}, allWaypoints.vertical, allWaypoints.horizontal);
         return $.each(waypoints, function(key, waypoint) {
           waypoint[method]();
           return true;
         });
       },
       _filter: function(selector, axis, test) {
         var context, waypoints;
 
         context = contexts[$(selector).data(contextKey)];
         if (!context) {
           return [];
         }
         waypoints = [];
         $.each(context.waypoints[axis], function(i, waypoint) {
           if (test(context, waypoint)) {
             return waypoints.push(waypoint);
           }
         });
         waypoints.sort(function(a, b) {
           return a.offset - b.offset;
         });
         return $.map(waypoints, function(waypoint) {
           return waypoint.element;
         });
       }
     };
     $[wps] = function() {
       var args, method;
 
       method = arguments[0], args = 2 <= arguments.length ? __slice.call(arguments, 1) : [];
       if (jQMethods[method]) {
         return jQMethods[method].apply(null, args);
       } else {
         return jQMethods.aggregate.call(null, method);
       }
     };
     $[wps].settings = {
       resizeThrottle: 100,
       scrollThrottle: 30
     };
     return $w.load(function() {
       return $[wps]('refresh');
     });
   });
 
 }).call(this);