windowevents.js

(function (global, factory) {
  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
  typeof define === 'function' && define.amd ? define(factory) :
  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.WindowEvents = factory());
}(this, (function () { 'use strict';

  function _classCallCheck(instance, Constructor) {
    if (!(instance instanceof Constructor)) {
      throw new TypeError("Cannot call a class as a function");
    }
  }

  function _defineProperties(target, props) {
    for (var i = 0; i < props.length; i++) {
      var descriptor = props[i];
      descriptor.enumerable = descriptor.enumerable || false;
      descriptor.configurable = true;
      if ("value" in descriptor) descriptor.writable = true;
      Object.defineProperty(target, descriptor.key, descriptor);
    }
  }

  function _createClass(Constructor, protoProps, staticProps) {
    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
    if (staticProps) _defineProperties(Constructor, staticProps);
    return Constructor;
  }

  function _defineProperty(obj, key, value) {
    if (key in obj) {
      Object.defineProperty(obj, key, {
        value: value,
        enumerable: true,
        configurable: true,
        writable: true
      });
    } else {
      obj[key] = value;
    }

    return obj;
  }

  function ownKeys(object, enumerableOnly) {
    var keys = Object.keys(object);

    if (Object.getOwnPropertySymbols) {
      var symbols = Object.getOwnPropertySymbols(object);
      if (enumerableOnly) symbols = symbols.filter(function (sym) {
        return Object.getOwnPropertyDescriptor(object, sym).enumerable;
      });
      keys.push.apply(keys, symbols);
    }

    return keys;
  }

  function _objectSpread2(target) {
    for (var i = 1; i < arguments.length; i++) {
      var source = arguments[i] != null ? arguments[i] : {};

      if (i % 2) {
        ownKeys(Object(source), true).forEach(function (key) {
          _defineProperty(target, key, source[key]);
        });
      } else if (Object.getOwnPropertyDescriptors) {
        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
      } else {
        ownKeys(Object(source)).forEach(function (key) {
          Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
        });
      }
    }

    return target;
  }

  /**
   * @author Dave Devor <davedevor@gmail.com>
   */

  /**
   * Constuctor to create an object to hold all of the apps covenants.
   * @type {Function}
   */
  function Covenant() {
    /**
     * Checks if a variable is a function
     * @param  {Function} fn
     *
     * @returns {Boolean}
     */
    function isFn(fn) {
      return Object.prototype.toString.call(fn) === '[object Function]';
    }
    /**
     * Store incrementing ID for each passed callback
     * @type  {Int}
     */


    var callbackId = 0;
    /**
     * Store all of our covenants
     * @type  {Array}
     */

    var covenants = [];
    /**
     * Register an event, or add to an existing event
     * @param   {String}  name    Name of the event like: 'loaded'
     * @param   {Function}  fn    The closure to execute when signaled.
     * @return  {Mixed}           Unique ID for listener or false on incorrect parameters
     */

    this.on = function on() {
      var name = arguments.length <= 0 || arguments[0] === undefined ? false : arguments[0];
      var fn = arguments.length <= 1 || arguments[1] === undefined ? false : arguments[1]; // Make sure the fn is a function

      if (name && fn && isFn(fn)) {
        var _exists = false;
        var cbObj = {
          id: 'cov_' + ++callbackId,
          fn: fn
        }; // check if this even exists

        covenants.forEach(function (cov) {
          // If it already exists, add the function to its functions.
          if (cov.name === name) {
            cov.callbacks.push(cbObj);
            _exists = true;
            return;
          }
        }); // If it doesnt exist create it.

        if (!_exists) {
          var newCovenant = {
            name: name,
            callbacks: [cbObj]
          };
          covenants.push(newCovenant);
        }

        return cbObj.id;
      }

      return false;
    };
    /**
     * Register an event to fire only once
     * @param   {String}  name    Name of the event like: 'loaded'
     * @param   {Function}  fn    The closure to execute when signaled.
     * @return  {Mixed}           Unique ID for listener or false on incorrect parameters
     */


    this.once = function once() {
      var name = arguments.length <= 0 || arguments[0] === undefined ? false : arguments[0];
      var fn = arguments.length <= 1 || arguments[1] === undefined ? false : arguments[1];

      if (name && fn && isFn(fn)) {
        var newId = 'cov_' + (callbackId + 1);

        var oneTimeFunc = function () {
          fn.apply(null, arguments);
          this.off(name, newId);
        }.bind(this);

        this.on(name, oneTimeFunc);
        return newId;
      }

      return false;
    };
    /**
     * Signal an event and run all of its subscribed functions.
     * @param  {String}    name  Name of the event like: 'loaded';
     * @param  {object[]}  args  Any arguments that need to be sent to the  fn
     * @return {object}          Current instance of Cov, to allow for chaining
     */


    this.signal = function signal() {
      var name = arguments.length <= 0 || arguments[0] === undefined ? false : arguments[0];
      var args = arguments.length <= 1 || arguments[1] === undefined ? [] : arguments[1];

      if (name) {
        covenants.forEach(function (cov) {
          if (cov.name === name) {
            cov.callbacks.forEach(function (cbObj) {
              cbObj.fn.apply(null, args);
            });
            return;
          }
        });
      }

      return this;
    };
    /**
     * Unregister (turn off) an event.
     * @param  {String}           Name of the event like: 'loaded';
     * @param  {String|Function}  ID of listener as returned by `on` function, or the original function
     * @return {object}           Current instance of Cov, to allow for chaining
     */


    this.off = function off() {
      var name = arguments.length <= 0 || arguments[0] === undefined ? false : arguments[0];
      var id = arguments.length <= 1 || arguments[1] === undefined ? false : arguments[1];

      if (name) {
        covenants.forEach(function (cov, index, arr) {
          if (cov.name === name) {
            // If no ID is passed, remove all listeners
            if (!id) {
              arr.splice(index, 1);
            } else {
              // Otherwise just remove specified callback
              cov.callbacks.forEach(function (cbObj, ix, callbacks) {
                // Remove based off ID or the reference of the function passed matches original
                if (cbObj.id === id || isFn(id) && cbObj.fn === id) {
                  callbacks.splice(ix, 1);
                }
              });
            }

            return;
          }
        });
      }

      return this;
    };
  }

  var cov = new Covenant();
  var cov_1 = {
    cov: cov,
    Covenant: Covenant
  };

  /* eslint-disable no-undefined,no-param-reassign,no-shadow */

  /**
   * Throttle execution of a function. Especially useful for rate limiting
   * execution of handlers on events like resize and scroll.
   *
   * @param  {Number}    delay          A zero-or-greater delay in milliseconds. For event callbacks, values around 100 or 250 (or even higher) are most useful.
   * @param  {Boolean}   [noTrailing]   Optional, defaults to false. If noTrailing is true, callback will only execute every `delay` milliseconds while the
   *                                    throttled-function is being called. If noTrailing is false or unspecified, callback will be executed one final time
   *                                    after the last throttled-function call. (After the throttled-function has not been called for `delay` milliseconds,
   *                                    the internal counter is reset)
   * @param  {Function}  callback       A function to be executed after delay milliseconds. The `this` context and all arguments are passed through, as-is,
   *                                    to `callback` when the throttled-function is executed.
   * @param  {Boolean}   [debounceMode] If `debounceMode` is true (at begin), schedule `clear` to execute after `delay` ms. If `debounceMode` is false (at end),
   *                                    schedule `callback` to execute after `delay` ms.
   *
   * @return {Function}  A new, throttled, function.
   */
  var throttle = function throttle(delay, noTrailing, callback, debounceMode) {
    // After wrapper has stopped being called, this timeout ensures that
    // `callback` is executed at the proper times in `throttle` and `end`
    // debounce modes.
    var timeoutID; // Keep track of the last time `callback` was executed.

    var lastExec = 0; // `noTrailing` defaults to falsy.

    if (typeof noTrailing !== 'boolean') {
      debounceMode = callback;
      callback = noTrailing;
      noTrailing = undefined;
    } // The `wrapper` function encapsulates all of the throttling / debouncing
    // functionality and when executed will limit the rate at which `callback`
    // is executed.


    function wrapper() {
      var self = this;
      var elapsed = Number(new Date()) - lastExec;
      var args = arguments; // Execute `callback` and update the `lastExec` timestamp.

      function exec() {
        lastExec = Number(new Date());
        callback.apply(self, args);
      } // If `debounceMode` is true (at begin) this is used to clear the flag
      // to allow future `callback` executions.


      function clear() {
        timeoutID = undefined;
      }

      if (debounceMode && !timeoutID) {
        // Since `wrapper` is being called for the first time and
        // `debounceMode` is true (at begin), execute `callback`.
        exec();
      } // Clear any existing timeout.


      if (timeoutID) {
        clearTimeout(timeoutID);
      }

      if (debounceMode === undefined && elapsed > delay) {
        // In throttle mode, if `delay` time has been exceeded, execute
        // `callback`.
        exec();
      } else if (noTrailing !== true) {
        // In trailing throttle mode, since `delay` time has not been
        // exceeded, schedule `callback` to execute `delay` ms after most
        // recent execution.
        //
        // If `debounceMode` is true (at begin), schedule `clear` to execute
        // after `delay` ms.
        //
        // If `debounceMode` is false (at end), schedule `callback` to
        // execute after `delay` ms.
        timeoutID = setTimeout(debounceMode ? clear : exec, debounceMode === undefined ? delay - elapsed : delay);
      }
    } // Return the wrapper function.


    return wrapper;
  };

  /* eslint-disable no-undefined */
  /**
   * Debounce execution of a function. Debouncing, unlike throttling,
   * guarantees that a function is only executed a single time, either at the
   * very beginning of a series of calls, or at the very end.
   *
   * @param  {Number}   delay         A zero-or-greater delay in milliseconds. For event callbacks, values around 100 or 250 (or even higher) are most useful.
   * @param  {Boolean}  [atBegin]     Optional, defaults to false. If atBegin is false or unspecified, callback will only be executed `delay` milliseconds
   *                                  after the last debounced-function call. If atBegin is true, callback will be executed only at the first debounced-function call.
   *                                  (After the throttled-function has not been called for `delay` milliseconds, the internal counter is reset).
   * @param  {Function} callback      A function to be executed after delay milliseconds. The `this` context and all arguments are passed through, as-is,
   *                                  to `callback` when the debounced-function is executed.
   *
   * @return {Function} A new, debounced function.
   */

  var debounce = function debounce(delay, atBegin, callback) {
    return callback === undefined ? throttle(delay, atBegin, false) : throttle(delay, callback, atBegin !== false);
  };

  var ScrollEvents = /*#__PURE__*/function () {
    function ScrollEvents(publisher, options, sizeRef) {
      _classCallCheck(this, ScrollEvents);

      this.signal = publisher.signal;
      this.options = options;
      this.windowSize = sizeRef;
      this.scrollTimeout = null;
      this.debouncedListener = this.debouncedListener.bind(this);
      this.throttledListener = this.throttledListener.bind(this);
      this.updateState();
    }

    _createClass(ScrollEvents, [{
      key: "updateState",
      value: function updateState() {
        this.scrollTop = this.lastScrollTop = window.scrollY || window.pageYOffset;
        this.scrollPercent = this.scrollTop / (this.windowSize.scrollHeight - this.windowSize.height) * 100;
      }
    }, {
      key: "getState",
      value: function getState() {
        return {
          scrollTop: this.scrollTop,
          scrollPercent: this.scrollPercent
        };
      }
    }, {
      key: "debouncedListener",
      value: function debouncedListener() {
        this.scrollTop = window.scrollY || window.pageYOffset;
        this.scrollPercent = this.scrollTop / (this.windowSize.scrollHeight - this.windowSize.height) * 100;
        this.signal('scroll.start', [{
          scrollTop: this.scrollTop,
          scrollPercent: this.scrollPercent
        }]);
        this.lastScrollTop = this.scrollTop;
      }
    }, {
      key: "throttledListener",
      value: function throttledListener() {
        var _this = this;

        this.scrollTop = window.scrollY || window.pageYOffset;
        this.scrollPercent = this.scrollTop / (this.windowSize.scrollHeight - this.windowSize.height) * 100;
        var scrollObj = {
          scrollTop: this.scrollTop,
          scrollPercent: this.scrollPercent
        };
        this.signal('scroll', [scrollObj]);

        if (this.scrollTop > this.lastScrollTop) {
          this.signal('scroll.down', [scrollObj]);
        } else if (this.scrollTop < this.lastScrollTop) {
          this.signal('scroll.up', [scrollObj]);
        }

        if (this.scrollTop <= 0) {
          this.signal('scroll.top', [scrollObj]);
        }

        if (scrollObj.scrollPercent >= 100) {
          this.signal('scroll.bottom', [scrollObj]);
        }

        clearTimeout(this.scrollTimeout);
        this.scrollTimeout = setTimeout(function () {
          _this.signal('scroll.stop', [scrollObj]);
        }, this.options.scrollDelay + 1);
        this.lastScrollTop = this.scrollTop;
      }
    }]);

    return ScrollEvents;
  }();

  var ResizeEvents = /*#__PURE__*/function () {
    function ResizeEvents(publisher, options) {
      _classCallCheck(this, ResizeEvents);

      this.signal = publisher.signal;
      this.options = options;
      this.resizeTimeout = null;
      this.debouncedListener = this.debouncedListener.bind(this);
      this.throttledListener = this.throttledListener.bind(this);
      this.updateState();
    }

    _createClass(ResizeEvents, [{
      key: "updateState",
      value: function updateState() {
        this.height = this.lastH = window.innerHeight;
        this.width = this.lastW = window.innerWidth;
        this.scrollHeight = this.lastS = document.body.scrollHeight;
        this.orientation = this.lastO = this.height > this.width ? 'portrait' : 'landscape';
      }
    }, {
      key: "getState",
      value: function getState() {
        return {
          height: this.height,
          width: this.width,
          scrollHeight: this.scrollHeight,
          orientation: this.orientation
        };
      }
    }, {
      key: "debouncedListener",
      value: function debouncedListener() {
        this.height = window.innerHeight;
        this.width = window.innerWidth;
        this.scrollHeight = document.body.scrollHeight;
        this.orientation = this.height > this.width ? 'portrait' : 'landscape';
        var sizeObj = {
          height: this.height,
          width: this.width,
          scrollHeight: this.scrollHeight,
          orientation: this.orientation
        };
        this.signal('resize.start', [sizeObj]);
        this.lastH = this.height;
        this.lastW = this.width;
        this.lastS = this.scrollHeight;
      }
    }, {
      key: "throttledListener",
      value: function throttledListener() {
        var _this = this;

        this.height = window.innerHeight;
        this.width = window.innerWidth;
        this.scrollHeight = document.body.scrollHeight;
        this.orientation = this.height > this.width ? 'portrait' : 'landscape';
        var sizeObj = {
          height: this.height,
          width: this.width,
          scrollHeight: this.scrollHeight,
          orientation: this.orientation
        };
        this.signal('resize', [sizeObj]);

        if (this.orientation !== this.lastO) {
          this.signal('resize.orientationChange', [sizeObj]);
        }

        if (this.scrollHeight !== this.lastS) {
          this.signal('resize.scrollHeightChange', [sizeObj]);
        }

        clearTimeout(this.scrollTimeout);
        this.scrollTimeout = setTimeout(function () {
          _this.signal('resize.stop', [sizeObj]);
        }, this.options.resizeDelay + 1);
        this.lastH = this.height;
        this.lastW = this.width;
        this.lastS = this.scrollHeight;
        this.lastO = this.orientation;
      }
    }]);

    return ResizeEvents;
  }();

  var VisibilityEvents = /*#__PURE__*/function () {
    function VisibilityEvents(publisher, options) {
      _classCallCheck(this, VisibilityEvents);

      this.signal = publisher.signal;
      this.options = options;
      this.changeListenter = this.changeListenter.bind(this);
      this.updateState();
    }

    _createClass(VisibilityEvents, [{
      key: "updateState",
      value: function updateState() {
        this.visible = !document.hidden;
      }
    }, {
      key: "getState",
      value: function getState() {
        return {
          visible: this.visible
        };
      }
    }, {
      key: "changeListenter",
      value: function changeListenter() {
        this.visible = !document.hidden;
        var visibleObj = {
          visible: this.visible
        };
        this.signal('visibilityChange', [visibleObj]);

        if (this.visible) {
          this.signal('visibilityChange.show', [visibleObj]);
        } else {
          this.signal('visibilityChange.hide', [visibleObj]);
        }
      }
    }]);

    return VisibilityEvents;
  }();

  var LoadEvents = /*#__PURE__*/function () {
    function LoadEvents(publisher, options) {
      _classCallCheck(this, LoadEvents);

      this.signal = publisher.signal;
      this.options = options;
      this.changeListenter = this.changeListenter.bind(this);
      this.updateState();
    }

    _createClass(LoadEvents, [{
      key: "updateState",
      value: function updateState() {
        this.loaded = document.readyState;
      }
    }, {
      key: "getState",
      value: function getState() {
        return {
          loaded: this.loaded
        };
      }
    }, {
      key: "changeListenter",
      value: function changeListenter() {
        this.loaded = document.readyState;
        var loadedObj = {
          loaded: this.loaded
        };
        this.signal('load', [loadedObj]);

        if (this.loaded === 'interactive') {
          this.signal('load.interactive', [loadedObj]);
        } else if (this.loaded === 'complete') {
          this.signal('load.complete', [loadedObj]);
        }
      }
    }]);

    return LoadEvents;
  }();

  var WindowEvents = function WindowEvents(opts) {
    var _this = this;

    _classCallCheck(this, WindowEvents);

    var defaultOptions = {
      scrollDelay: 100,
      resizeDelay: 350
    };
    this.options = opts ? _objectSpread2(_objectSpread2({}, defaultOptions), opts) : defaultOptions;
    var publisher = new cov_1.Covenant();
    this.on = publisher.on;
    this.once = publisher.once;
    this.off = publisher.off;
    var resizeEvents = new ResizeEvents(publisher, this.options); // Pass resizeEvents object to scroll listener
    // in order to have access to window height, width

    var scrollEvents = new ScrollEvents(publisher, this.options, resizeEvents);
    var visibilityEvents = new VisibilityEvents(publisher, this.options);
    var loadEvents = new LoadEvents(publisher, this.options);

    this.getState = function () {
      return _objectSpread2(_objectSpread2(_objectSpread2(_objectSpread2({}, resizeEvents.getState()), scrollEvents.getState()), visibilityEvents.getState()), loadEvents.getState());
    };

    this.updateState = function () {
      resizeEvents.updateState();
      scrollEvents.updateState();
      visibilityEvents.updateState();
      loadEvents.updateState();
      return _this.getState();
    };

    window.addEventListener('scroll', debounce( // Delay
    this.options.scrollDelay, // At beginning
    true, // Debounced function
    scrollEvents.debouncedListener), false);
    window.addEventListener('scroll', throttle( // Delay
    this.options.scrollDelay, // No Trailing. If false, will get called one last time after the last throttled call
    false, // Throttled function
    scrollEvents.throttledListener), false);
    window.addEventListener('resize', debounce( // Delay
    this.options.resizeDelay, // At beginning
    true, // Debounced function
    resizeEvents.debouncedListener), false);
    window.addEventListener('resize', throttle( // Delay
    this.options.resizeDelay, // No Trailing. If false, will get called one last time after the last throttled call
    false, // Throttled function
    resizeEvents.throttledListener), false);
    window.addEventListener('visibilitychange', visibilityEvents.changeListenter, false);
    document.addEventListener('readystatechange', function () {
      // Update the state once all
      // images and resources have loaded
      _this.updateState();

      loadEvents.changeListenter();
    }, false);
  };

  return WindowEvents;

})));
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"windowevents.js","sources":["node_modules/covjs/cov.js","node_modules/throttle-debounce/throttle.js","node_modules/throttle-debounce/debounce.js","src/scroll.js","src/resize.js","src/visibility.js","src/load.js","src/index.js"],"sourcesContent":["/**\n * @author Dave Devor <davedevor@gmail.com>\n */\n\n/**\n * Constuctor to create an object to hold all of the apps covenants.\n * @type {Function}\n */\nfunction Covenant() {\n\t/**\n\t * Checks if a variable is a function\n\t * @param  {Function} fn\n\t *\n\t * @returns {Boolean}\n\t */\n\tfunction isFn(fn) {\n\t\treturn Object.prototype.toString.call(fn) === '[object Function]';\n\t}\n\n\t/**\n\t * Store incrementing ID for each passed callback\n\t * @type  {Int}\n\t */\n\tvar callbackId = 0;\n\n\t/**\n\t * Store all of our covenants\n\t * @type  {Array}\n\t */\n\tvar covenants = [];\n\n\t/**\n\t * Register an event, or add to an existing event\n\t * @param   {String}  name    Name of the event like: 'loaded'\n\t * @param   {Function}  fn    The closure to execute when signaled.\n\t * @return  {Mixed}           Unique ID for listener or false on incorrect parameters\n\t */\n\tthis.on = function on() {\n\t\tvar name = arguments.length <= 0 || arguments[0] === undefined ? false : arguments[0];\n\t\tvar fn = arguments.length <= 1 || arguments[1] === undefined ? false : arguments[1];\n\n\t\t// Make sure the fn is a function\n\t\tif (name && fn && isFn(fn)) {\n\t\t\tvar _exists = false;\n\t\t\tvar cbObj = {\n\t\t\t\tid: 'cov_' + (++callbackId),\n\t\t\t\tfn: fn\n\t\t\t}\n\n\t\t\t// check if this even exists\n\t\t\tcovenants.forEach(function (cov) {\n\t\t\t\t// If it already exists, add the function to its functions.\n\t\t\t\tif (cov.name === name) {\n\t\t\t\t\tcov.callbacks.push(cbObj);\n\t\t\t\t\t_exists = true;\n\t\t\t\t\treturn;\n\t\t\t\t}\n\t\t\t});\n\n\t\t\t// If it doesnt exist create it.\n\t\t\tif (!_exists) {\n\t\t\t\tvar newCovenant = {\n\t\t\t\t\tname: name,\n\t\t\t\t\tcallbacks: [cbObj]\n\t\t\t\t};\n\n\t\t\t\tcovenants.push(newCovenant);\n\t\t\t}\n\t\t\treturn cbObj.id;\n\t\t}\n\t\treturn false;\n\t};\n\n\t/**\n\t * Register an event to fire only once\n\t * @param   {String}  name    Name of the event like: 'loaded'\n\t * @param   {Function}  fn    The closure to execute when signaled.\n\t * @return  {Mixed}           Unique ID for listener or false on incorrect parameters\n\t */\n\tthis.once = function once() {\n\t\tvar name = arguments.length <= 0 || arguments[0] === undefined ? false : arguments[0];\n\t\tvar fn = arguments.length <= 1 || arguments[1] === undefined ? false : arguments[1];\n\n\t\tif (name && fn && isFn(fn)) {\n\t\t\tvar newId = 'cov_' + (callbackId + 1);\n\t\t\tvar oneTimeFunc = function() {\n\t\t\t\tfn.apply(null, arguments);\n\t\t\t\tthis.off(name, newId);\n\t\t\t}.bind(this);\n\n\t\t\tthis.on(name, oneTimeFunc);\n\n\t\t\treturn newId;\n\t\t}\n\n\t\treturn false;\n\t};\n\n\t/**\n\t * Signal an event and run all of its subscribed functions.\n\t * @param  {String}    name  Name of the event like: 'loaded';\n\t * @param  {object[]}  args  Any arguments that need to be sent to the  fn\n\t * @return {object}          Current instance of Cov, to allow for chaining\n\t */\n\tthis.signal = function signal() {\n\t\tvar name = arguments.length <= 0 || arguments[0] === undefined ? false : arguments[0];\n\t\tvar args = arguments.length <= 1 || arguments[1] === undefined ? [] : arguments[1];\n\n\t\tif (name) {\n\t\t\tcovenants.forEach(function (cov) {\n\t\t\t\tif (cov.name === name) {\n\n\t\t\t\t\tcov.callbacks.forEach(function (cbObj) {\n\t\t\t\t\t\tcbObj.fn.apply(null, args);\n\t\t\t\t\t});\n\n\t\t\t\t\treturn;\n\t\t\t\t}\n\t\t\t});\n\t\t}\n\n\t\treturn this;\n\t};\n\n\t/**\n\t * Unregister (turn off) an event.\n\t * @param  {String}           Name of the event like: 'loaded';\n\t * @param  {String|Function}  ID of listener as returned by `on` function, or the original function\n\t * @return {object}           Current instance of Cov, to allow for chaining\n\t */\n\tthis.off = function off() {\n\t\tvar name = arguments.length <= 0 || arguments[0] === undefined ? false : arguments[0];\n\t\tvar id = arguments.length <= 1 || arguments[1] === undefined ? false : arguments[1];\n\n\t\tif (name) {\n\t\t\tcovenants.forEach(function (cov, index, arr) {\n\t\t\t\tif (cov.name === name) {\n\t\t\t\t\t// If no ID is passed, remove all listeners\n\t\t\t\t\tif (!id) {\n\t\t\t\t\t\tarr.splice(index, 1);\n\t\t\t\t\t}\n\t\t\t\t\telse {\n\t\t\t\t\t// Otherwise just remove specified callback\n\t\t\t\t\t\tcov.callbacks.forEach(function (cbObj, ix, callbacks) {\n\t\t\t\t\t\t\t// Remove based off ID or the reference of the function passed matches original\n\t\t\t\t\t\t\tif (cbObj.id === id || (isFn(id) && cbObj.fn === id)) {\n\t\t\t\t\t\t\t\tcallbacks.splice(ix, 1);\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t});\n\t\t\t\t\t}\n\t\t\t\t\treturn;\n\t\t\t\t}\n\t\t\t});\n\t\t}\n\n\t\treturn this;\n\t};\n}\n\nvar cov = new Covenant();\n\nmodule.exports = {\n\tcov: cov,\n\tCovenant: Covenant\n};\n","/* eslint-disable no-undefined,no-param-reassign,no-shadow */\n\n/**\n * Throttle execution of a function. Especially useful for rate limiting\n * execution of handlers on events like resize and scroll.\n *\n * @param  {Number}    delay          A zero-or-greater delay in milliseconds. For event callbacks, values around 100 or 250 (or even higher) are most useful.\n * @param  {Boolean}   [noTrailing]   Optional, defaults to false. If noTrailing is true, callback will only execute every `delay` milliseconds while the\n *                                    throttled-function is being called. If noTrailing is false or unspecified, callback will be executed one final time\n *                                    after the last throttled-function call. (After the throttled-function has not been called for `delay` milliseconds,\n *                                    the internal counter is reset)\n * @param  {Function}  callback       A function to be executed after delay milliseconds. The `this` context and all arguments are passed through, as-is,\n *                                    to `callback` when the throttled-function is executed.\n * @param  {Boolean}   [debounceMode] If `debounceMode` is true (at begin), schedule `clear` to execute after `delay` ms. If `debounceMode` is false (at end),\n *                                    schedule `callback` to execute after `delay` ms.\n *\n * @return {Function}  A new, throttled, function.\n */\nmodule.exports = function ( delay, noTrailing, callback, debounceMode ) {\n\n\t// After wrapper has stopped being called, this timeout ensures that\n\t// `callback` is executed at the proper times in `throttle` and `end`\n\t// debounce modes.\n\tvar timeoutID;\n\n\t// Keep track of the last time `callback` was executed.\n\tvar lastExec = 0;\n\n\t// `noTrailing` defaults to falsy.\n\tif ( typeof noTrailing !== 'boolean' ) {\n\t\tdebounceMode = callback;\n\t\tcallback = noTrailing;\n\t\tnoTrailing = undefined;\n\t}\n\n\t// The `wrapper` function encapsulates all of the throttling / debouncing\n\t// functionality and when executed will limit the rate at which `callback`\n\t// is executed.\n\tfunction wrapper () {\n\n\t\tvar self = this;\n\t\tvar elapsed = Number(new Date()) - lastExec;\n\t\tvar args = arguments;\n\n\t\t// Execute `callback` and update the `lastExec` timestamp.\n\t\tfunction exec () {\n\t\t\tlastExec = Number(new Date());\n\t\t\tcallback.apply(self, args);\n\t\t}\n\n\t\t// If `debounceMode` is true (at begin) this is used to clear the flag\n\t\t// to allow future `callback` executions.\n\t\tfunction clear () {\n\t\t\ttimeoutID = undefined;\n\t\t}\n\n\t\tif ( debounceMode && !timeoutID ) {\n\t\t\t// Since `wrapper` is being called for the first time and\n\t\t\t// `debounceMode` is true (at begin), execute `callback`.\n\t\t\texec();\n\t\t}\n\n\t\t// Clear any existing timeout.\n\t\tif ( timeoutID ) {\n\t\t\tclearTimeout(timeoutID);\n\t\t}\n\n\t\tif ( debounceMode === undefined && elapsed > delay ) {\n\t\t\t// In throttle mode, if `delay` time has been exceeded, execute\n\t\t\t// `callback`.\n\t\t\texec();\n\n\t\t} else if ( noTrailing !== true ) {\n\t\t\t// In trailing throttle mode, since `delay` time has not been\n\t\t\t// exceeded, schedule `callback` to execute `delay` ms after most\n\t\t\t// recent execution.\n\t\t\t//\n\t\t\t// If `debounceMode` is true (at begin), schedule `clear` to execute\n\t\t\t// after `delay` ms.\n\t\t\t//\n\t\t\t// If `debounceMode` is false (at end), schedule `callback` to\n\t\t\t// execute after `delay` ms.\n\t\t\ttimeoutID = setTimeout(debounceMode ? clear : exec, debounceMode === undefined ? delay - elapsed : delay);\n\t\t}\n\n\t}\n\n\t// Return the wrapper function.\n\treturn wrapper;\n\n};\n","/* eslint-disable no-undefined */\n\nvar throttle = require('./throttle');\n\n/**\n * Debounce execution of a function. Debouncing, unlike throttling,\n * guarantees that a function is only executed a single time, either at the\n * very beginning of a series of calls, or at the very end.\n *\n * @param  {Number}   delay         A zero-or-greater delay in milliseconds. For event callbacks, values around 100 or 250 (or even higher) are most useful.\n * @param  {Boolean}  [atBegin]     Optional, defaults to false. If atBegin is false or unspecified, callback will only be executed `delay` milliseconds\n *                                  after the last debounced-function call. If atBegin is true, callback will be executed only at the first debounced-function call.\n *                                  (After the throttled-function has not been called for `delay` milliseconds, the internal counter is reset).\n * @param  {Function} callback      A function to be executed after delay milliseconds. The `this` context and all arguments are passed through, as-is,\n *                                  to `callback` when the debounced-function is executed.\n *\n * @return {Function} A new, debounced function.\n */\nmodule.exports = function ( delay, atBegin, callback ) {\n\treturn callback === undefined ? throttle(delay, atBegin, false) : throttle(delay, callback, atBegin !== false);\n};\n","class ScrollEvents {\n  constructor (publisher, options, sizeRef) {\n    this.signal = publisher.signal\n    this.options = options\n    this.windowSize = sizeRef\n    this.scrollTimeout = null\n\n    this.debouncedListener = this.debouncedListener.bind(this)\n    this.throttledListener = this.throttledListener.bind(this)\n\n    this.updateState()\n  }\n\n  updateState () {\n    this.scrollTop = this.lastScrollTop = window.scrollY || window.pageYOffset\n    this.scrollPercent =\n        (this.scrollTop / (this.windowSize.scrollHeight - this.windowSize.height)) * 100\n  }\n\n  getState () {\n    return {\n      scrollTop: this.scrollTop,\n      scrollPercent: this.scrollPercent\n    }\n  }\n\n  debouncedListener () {\n    this.scrollTop = window.scrollY || window.pageYOffset\n    this.scrollPercent =\n        (this.scrollTop / (this.windowSize.scrollHeight - this.windowSize.height)) * 100\n\n    this.signal('scroll.start', [{\n      scrollTop: this.scrollTop,\n      scrollPercent: this.scrollPercent\n    }])\n\n    this.lastScrollTop = this.scrollTop\n  }\n\n  throttledListener () {\n    this.scrollTop = window.scrollY || window.pageYOffset\n    this.scrollPercent =\n        (this.scrollTop / (this.windowSize.scrollHeight - this.windowSize.height)) * 100\n\n    const scrollObj = {\n      scrollTop: this.scrollTop,\n      scrollPercent: this.scrollPercent\n    }\n\n    this.signal('scroll', [scrollObj])\n\n    if (this.scrollTop > this.lastScrollTop) {\n      this.signal('scroll.down', [scrollObj])\n    } else if (this.scrollTop < this.lastScrollTop) {\n      this.signal('scroll.up', [scrollObj])\n    }\n\n    if (this.scrollTop <= 0) {\n      this.signal('scroll.top', [scrollObj])\n    }\n\n    if (scrollObj.scrollPercent >= 100) {\n      this.signal('scroll.bottom', [scrollObj])\n    }\n\n    clearTimeout(this.scrollTimeout)\n    this.scrollTimeout = setTimeout(() => {\n      this.signal('scroll.stop', [scrollObj])\n    }, this.options.scrollDelay + 1)\n\n    this.lastScrollTop = this.scrollTop\n  }\n}\n\nexport default ScrollEvents\n","class ResizeEvents {\n  constructor (publisher, options) {\n    this.signal = publisher.signal\n    this.options = options\n    this.resizeTimeout = null\n\n    this.debouncedListener = this.debouncedListener.bind(this)\n    this.throttledListener = this.throttledListener.bind(this)\n\n    this.updateState()\n  }\n\n  updateState () {\n    this.height = this.lastH = window.innerHeight\n    this.width = this.lastW = window.innerWidth\n    this.scrollHeight = this.lastS = document.body.scrollHeight\n    this.orientation = this.lastO = this.height > this.width ? 'portrait' : 'landscape'\n  }\n\n  getState () {\n    return {\n      height: this.height,\n      width: this.width,\n      scrollHeight: this.scrollHeight,\n      orientation: this.orientation\n    }\n  }\n\n  debouncedListener () {\n    this.height = window.innerHeight\n    this.width = window.innerWidth\n    this.scrollHeight = document.body.scrollHeight\n    this.orientation = this.height > this.width ? 'portrait' : 'landscape'\n\n    const sizeObj = {\n      height: this.height,\n      width: this.width,\n      scrollHeight: this.scrollHeight,\n      orientation: this.orientation\n    }\n\n    this.signal('resize.start', [sizeObj])\n\n    this.lastH = this.height\n    this.lastW = this.width\n    this.lastS = this.scrollHeight\n  }\n\n  throttledListener () {\n    this.height = window.innerHeight\n    this.width = window.innerWidth\n    this.scrollHeight = document.body.scrollHeight\n    this.orientation = this.height > this.width ? 'portrait' : 'landscape'\n\n    const sizeObj = {\n      height: this.height,\n      width: this.width,\n      scrollHeight: this.scrollHeight,\n      orientation: this.orientation\n    }\n\n    this.signal('resize', [sizeObj])\n\n    if (this.orientation !== this.lastO) {\n      this.signal('resize.orientationChange', [sizeObj])\n    }\n\n    if (this.scrollHeight !== this.lastS) {\n      this.signal('resize.scrollHeightChange', [sizeObj])\n    }\n\n    clearTimeout(this.scrollTimeout)\n    this.scrollTimeout = setTimeout(() => {\n      this.signal('resize.stop', [sizeObj])\n    }, this.options.resizeDelay + 1)\n\n    this.lastH = this.height\n    this.lastW = this.width\n    this.lastS = this.scrollHeight\n    this.lastO = this.orientation\n  }\n}\n\nexport default ResizeEvents\n","class VisibilityEvents {\n  constructor (publisher, options) {\n    this.signal = publisher.signal\n    this.options = options\n\n    this.changeListenter = this.changeListenter.bind(this)\n\n    this.updateState()\n  }\n\n  updateState () {\n    this.visible = !document.hidden\n  }\n\n  getState () {\n    return {\n      visible: this.visible\n    }\n  }\n\n  changeListenter () {\n    this.visible = !document.hidden\n\n    const visibleObj = {\n      visible: this.visible\n    }\n\n    this.signal('visibilityChange', [visibleObj])\n\n    if (this.visible) {\n      this.signal('visibilityChange.show', [visibleObj])\n    } else {\n      this.signal('visibilityChange.hide', [visibleObj])\n    }\n  }\n}\n\nexport default VisibilityEvents\n","class LoadEvents {\n  constructor (publisher, options) {\n    this.signal = publisher.signal\n    this.options = options\n\n    this.changeListenter = this.changeListenter.bind(this)\n\n    this.updateState()\n  }\n\n  updateState () {\n    this.loaded = document.readyState\n  }\n\n  getState () {\n    return {\n      loaded: this.loaded\n    }\n  }\n\n  changeListenter () {\n    this.loaded = document.readyState\n\n    const loadedObj = {\n      loaded: this.loaded\n    }\n\n    this.signal('load', [loadedObj])\n\n    if (this.loaded === 'interactive') {\n      this.signal('load.interactive', [loadedObj])\n    } else if (this.loaded === 'complete') {\n      this.signal('load.complete', [loadedObj])\n    }\n  }\n}\n\nexport default LoadEvents\n","/*!\n * WindowEvents.js\n * @author Pete Droll <droll.p@gmail.com>\n * @license MIT\n */\nimport { Covenant } from 'covjs'\nimport debounce from 'throttle-debounce/debounce'\nimport throttle from 'throttle-debounce/throttle'\nimport ScrollEvents from './scroll'\nimport ResizeEvents from './resize'\nimport VisibilityEvents from './visibility'\nimport LoadEvents from './load'\n\nclass WindowEvents {\n  constructor (opts) {\n    const defaultOptions = {\n      scrollDelay: 100,\n      resizeDelay: 350\n    }\n\n    this.options = opts ? { ...defaultOptions, ...opts } : defaultOptions\n\n    const publisher = new Covenant()\n    this.on = publisher.on\n    this.once = publisher.once\n    this.off = publisher.off\n\n    const resizeEvents = new ResizeEvents(publisher, this.options)\n    // Pass resizeEvents object to scroll listener\n    // in order to have access to window height, width\n    const scrollEvents = new ScrollEvents(publisher, this.options, resizeEvents)\n    const visibilityEvents = new VisibilityEvents(publisher, this.options)\n    const loadEvents = new LoadEvents(publisher, this.options)\n\n    this.getState = () => ({\n      ...resizeEvents.getState(),\n      ...scrollEvents.getState(),\n      ...visibilityEvents.getState(),\n      ...loadEvents.getState()\n    })\n\n    this.updateState = () => {\n      resizeEvents.updateState()\n      scrollEvents.updateState()\n      visibilityEvents.updateState()\n      loadEvents.updateState()\n      return this.getState()\n    }\n\n    window.addEventListener('scroll', debounce(\n      // Delay\n      this.options.scrollDelay,\n      // At beginning\n      true,\n      // Debounced function\n      scrollEvents.debouncedListener\n    ), false)\n    window.addEventListener('scroll', throttle(\n      // Delay\n      this.options.scrollDelay,\n      // No Trailing. If false, will get called one last time after the last throttled call\n      false,\n      // Throttled function\n      scrollEvents.throttledListener\n    ), false)\n    window.addEventListener('resize', debounce(\n      // Delay\n      this.options.resizeDelay,\n      // At beginning\n      true,\n      // Debounced function\n      resizeEvents.debouncedListener\n    ), false)\n    window.addEventListener('resize', throttle(\n      // Delay\n      this.options.resizeDelay,\n      // No Trailing. If false, will get called one last time after the last throttled call\n      false,\n      // Throttled function\n      resizeEvents.throttledListener\n    ), false)\n\n    window.addEventListener('visibilitychange', visibilityEvents.changeListenter, false)\n\n    document.addEventListener('readystatechange', () => {\n      // Update the state once all\n      // images and resources have loaded\n      this.updateState()\n      loadEvents.changeListenter()\n    }, false)\n  }\n}\n\nexport default WindowEvents\n"],"names":["Covenant","isFn","fn","Object","prototype","toString","call","callbackId","covenants","on","name","arguments","length","undefined","_exists","cbObj","id","forEach","cov","callbacks","push","newCovenant","once","newId","oneTimeFunc","apply","off","bind","signal","args","index","arr","splice","ix","delay","noTrailing","callback","debounceMode","timeoutID","lastExec","wrapper","self","elapsed","Number","Date","exec","clear","clearTimeout","setTimeout","atBegin","throttle","ScrollEvents","publisher","options","sizeRef","windowSize","scrollTimeout","debouncedListener","throttledListener","updateState","scrollTop","lastScrollTop","window","scrollY","pageYOffset","scrollPercent","scrollHeight","height","scrollObj","scrollDelay","ResizeEvents","resizeTimeout","lastH","innerHeight","width","lastW","innerWidth","lastS","document","body","orientation","lastO","sizeObj","resizeDelay","VisibilityEvents","changeListenter","visible","hidden","visibleObj","LoadEvents","loaded","readyState","loadedObj","WindowEvents","opts","defaultOptions","resizeEvents","scrollEvents","visibilityEvents","loadEvents","getState","addEventListener","debounce"],"mappings":"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"}