Subversion Repositories cheapmusic

/**

 * breakpoints-js v1.0.6

 * https://github.com/amazingSurge/breakpoints-js

 *

 * Copyright (c) amazingSurge

 * Released under the LGPL-3.0 license

 */

(function(global, factory) {

  if (typeof define === 'function' && define.amd) {

    define(['exports'], factory);

  } else if (typeof exports !== 'undefined') {

    factory(exports);

  } else {

    var mod = {

      exports: {}

    };

    factory(mod.exports);

    global.breakpointsEs = mod.exports;

  }

})(this, function(exports) {

  'use strict';

  Object.defineProperty(exports, '__esModule', {

    value: true

  });

  function _possibleConstructorReturn(self, call) {

    if (!self) {

      throw new ReferenceError(

        "this hasn't been initialised - super() hasn't been called"

      );

    }

    return call && (typeof call === 'object' || typeof call === 'function')

      ? call

      : self;

  }

  function _inherits(subClass, superClass) {

    if (typeof superClass !== 'function' && superClass !== null) {

      throw new TypeError(

        'Super expression must either be null or a function, not ' +

          typeof superClass

      );

    }

    subClass.prototype = Object.create(superClass && superClass.prototype, {

      constructor: {

        value: subClass,

        enumerable: false,

        writable: true,

        configurable: true

      }

    });

    if (superClass)

      Object.setPrototypeOf

        ? Object.setPrototypeOf(subClass, superClass)

        : (subClass.__proto__ = superClass);

  }

  function _classCallCheck(instance, Constructor) {

    if (!(instance instanceof Constructor)) {

      throw new TypeError('Cannot call a class as a function');

    }

  }

  var _createClass = (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);

      }

    }

    return function(Constructor, protoProps, staticProps) {

      if (protoProps) defineProperties(Constructor.prototype, protoProps);

      if (staticProps) defineProperties(Constructor, staticProps);

      return Constructor;

    };

  })();

  var _typeof =

    typeof Symbol === 'function' && typeof Symbol.iterator === 'symbol'

      ? function(obj) {

          return typeof obj;

        }

      : function(obj) {

          return obj &&

            typeof Symbol === 'function' &&

            obj.constructor === Symbol &&

            obj !== Symbol.prototype

            ? 'symbol'

            : typeof obj;

        };

  /**

   * breakpoints-js v1.0.6

   * https://github.com/amazingSurge/breakpoints-js

   *

   * Copyright (c) amazingSurge

   * Released under the LGPL-3.0 license

   */

  var defaults = {

    // Extra small devices (phones)

    xs: {

      min: 0,

      max: 767

    },

    // Small devices (tablets)

    sm: {

      min: 768,

      max: 991

    },

    // Medium devices (desktops)

    md: {

      min: 992,

      max: 1199

    },

    // Large devices (large desktops)

    lg: {

      min: 1200,

      max: Infinity

    }

  };

  var util = {

    each: function each(obj, fn) {

      var continues = void 0;

      for (var i in obj) {

        if (

          (typeof obj === 'undefined' ? 'undefined' : _typeof(obj)) !==

            'object' ||

          obj.hasOwnProperty(i)

        ) {

          continues = fn(i, obj[i]);

          if (continues === false) {

            break; //allow early exit

          }

        }

      }

    },

    isFunction: function isFunction(obj) {

      return typeof obj === 'function' || false;

    },

    extend: function extend(obj, source) {

      for (var property in source) {

        obj[property] = source[property];

      }

      return obj;

    }

  };

  var Callbacks = (function() {

    function Callbacks() {

      _classCallCheck(this, Callbacks);

      this.length = 0;

      this.list = [];

    }

    _createClass(Callbacks, [

      {

        key: 'add',

        value: function add(fn, data) {

          var one =

            arguments.length > 2 && arguments[2] !== undefined

              ? arguments[2]

              : false;

          this.list.push({

            fn: fn,

            data: data,

            one: one

          });

          this.length++;

        }

      },

      {

        key: 'remove',

        value: function remove(fn) {

          for (var i = 0; i < this.list.length; i++) {

            if (this.list[i].fn === fn) {

              this.list.splice(i, 1);

              this.length--;

              i--;

            }

          }

        }

      },

      {

        key: 'empty',

        value: function empty() {

          this.list = [];

          this.length = 0;

        }

      },

      {

        key: 'call',

        value: function call(caller, i) {

          var fn =

            arguments.length > 2 && arguments[2] !== undefined

              ? arguments[2]

              : null;

          if (!i) {

            i = this.length - 1;

          }

          var callback = this.list[i];

          if (util.isFunction(fn)) {

            fn.call(this, caller, callback, i);

          } else if (util.isFunction(callback.fn)) {

            callback.fn.call(caller || window, callback.data);

          }

          if (callback.one) {

            delete this.list[i];

            this.length--;

          }

        }

      },

      {

        key: 'fire',

        value: function fire(caller) {

          var fn =

            arguments.length > 1 && arguments[1] !== undefined

              ? arguments[1]

              : null;

          for (var i in this.list) {

            if (this.list.hasOwnProperty(i)) {

              this.call(caller, i, fn);

            }

          }

        }

      }

    ]);

    return Callbacks;

  })();

  var ChangeEvent = {

    current: null,

    callbacks: new Callbacks(),

    trigger: function trigger(size) {

      var previous = this.current;

      this.current = size;

      this.callbacks.fire(size, function(caller, callback) {

        if (util.isFunction(callback.fn)) {

          callback.fn.call(

            {

              current: size,

              previous: previous

            },

            callback.data

          );

        }

      });

    },

    one: function one(data, fn) {

      return this.on(data, fn, true);

    },

    on: function on(data, fn) {

      var one =

        arguments.length > 2 && arguments[2] !== undefined

          ? arguments[2]

          : false;

      if (typeof fn === 'undefined' && util.isFunction(data)) {

        fn = data;

        data = undefined;

      }

      if (util.isFunction(fn)) {

        this.callbacks.add(fn, data, one);

      }

    },

    off: function off(fn) {

      if (typeof fn === 'undefined') {

        this.callbacks.empty();

      }

    }

  };

  var MediaQuery = (function() {

    function MediaQuery(name, media) {

      _classCallCheck(this, MediaQuery);

      this.name = name;

      this.media = media;

      this.initialize();

    }

    _createClass(MediaQuery, [

      {

        key: 'initialize',

        value: function initialize() {

          this.callbacks = {

            enter: new Callbacks(),

            leave: new Callbacks()

          };

          this.mql = (window.matchMedia && window.matchMedia(this.media)) || {

            matches: false,

            media: this.media,

            addListener: function addListener() {

              // do nothing

            },

            removeListener: function removeListener() {

              // do nothing

            }

          };

          var that = this;

          this.mqlListener = function(mql) {

            var type = (mql.matches && 'enter') || 'leave';

            that.callbacks[type].fire(that);

          };

          this.mql.addListener(this.mqlListener);

        }

      },

      {

        key: 'on',

        value: function on(types, data, fn) {

          var one =

            arguments.length > 3 && arguments[3] !== undefined

              ? arguments[3]

              : false;

          if (

            (typeof types === 'undefined' ? 'undefined' : _typeof(types)) ===

            'object'

          ) {

            for (var type in types) {

              if (types.hasOwnProperty(type)) {

                this.on(type, data, types[type], one);

              }

            }

            return this;

          }

          if (typeof fn === 'undefined' && util.isFunction(data)) {

            fn = data;

            data = undefined;

          }

          if (!util.isFunction(fn)) {

            return this;

          }

          if (typeof this.callbacks[types] !== 'undefined') {

            this.callbacks[types].add(fn, data, one);

            if (types === 'enter' && this.isMatched()) {

              this.callbacks[types].call(this);

            }

          }

          return this;

        }

      },

      {

        key: 'one',

        value: function one(types, data, fn) {

          return this.on(types, data, fn, true);

        }

      },

      {

        key: 'off',

        value: function off(types, fn) {

          var type = void 0;

          if (

            (typeof types === 'undefined' ? 'undefined' : _typeof(types)) ===

            'object'

          ) {

            for (type in types) {

              if (types.hasOwnProperty(type)) {

                this.off(type, types[type]);

              }

            }

            return this;

          }

          if (typeof types === 'undefined') {

            this.callbacks.enter.empty();

            this.callbacks.leave.empty();

          } else if (types in this.callbacks) {

            if (fn) {

              this.callbacks[types].remove(fn);

            } else {

              this.callbacks[types].empty();

            }

          }

          return this;

        }

      },

      {

        key: 'isMatched',

        value: function isMatched() {

          return this.mql.matches;

        }

      },

      {

        key: 'destroy',

        value: function destroy() {

          this.off();

        }

      }

    ]);

    return MediaQuery;

  })();

  var MediaBuilder = {

    min: function min(_min) {

      var unit =

        arguments.length > 1 && arguments[1] !== undefined

          ? arguments[1]

          : 'px';

      return '(min-width: ' + _min + unit + ')';

    },

    max: function max(_max) {

      var unit =

        arguments.length > 1 && arguments[1] !== undefined

          ? arguments[1]

          : 'px';

      return '(max-width: ' + _max + unit + ')';

    },

    between: function between(min, max) {

      var unit =

        arguments.length > 2 && arguments[2] !== undefined

          ? arguments[2]

          : 'px';

      return (

        '(min-width: ' + min + unit + ') and (max-width: ' + max + unit + ')'

      );

    },

    get: function get(min, max) {

      var unit =

        arguments.length > 2 && arguments[2] !== undefined

          ? arguments[2]

          : 'px';

      if (min === 0) {

        return this.max(max, unit);

      }

      if (max === Infinity) {

        return this.min(min, unit);

      }

      return this.between(min, max, unit);

    }

  };

  var Size = (function(_MediaQuery) {

    _inherits(Size, _MediaQuery);

    function Size(name) {

      var min =

        arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;

      var max =

        arguments.length > 2 && arguments[2] !== undefined

          ? arguments[2]

          : Infinity;

      var unit =

        arguments.length > 3 && arguments[3] !== undefined

          ? arguments[3]

          : 'px';

      _classCallCheck(this, Size);

      var media = MediaBuilder.get(min, max, unit);

      var _this = _possibleConstructorReturn(

        this,

        (Size.__proto__ || Object.getPrototypeOf(Size)).call(this, name, media)

      );

      _this.min = min;

      _this.max = max;

      _this.unit = unit;

      var that = _this;

      _this.changeListener = function() {

        if (that.isMatched()) {

          ChangeEvent.trigger(that);

        }

      };

      if (_this.isMatched()) {

        ChangeEvent.current = _this;

      }

      _this.mql.addListener(_this.changeListener);

      return _this;

    }

    _createClass(Size, [

      {

        key: 'destroy',

        value: function destroy() {

          this.off();

          this.mql.removeListener(this.changeListener);

        }

      }

    ]);

    return Size;

  })(MediaQuery);

  var UnionSize = (function(_MediaQuery2) {

    _inherits(UnionSize, _MediaQuery2);

    function UnionSize(names) {

      _classCallCheck(this, UnionSize);

      var sizes = [];

      var media = [];

      util.each(names.split(' '), function(i, name) {

        var size = Breakpoints$1.get(name);

        if (size) {

          sizes.push(size);

          media.push(size.media);

        }

      });

      return _possibleConstructorReturn(

        this,

        (UnionSize.__proto__ || Object.getPrototypeOf(UnionSize)).call(

          this,

          names,

          media.join(',')

        )

      );

    }

    return UnionSize;

  })(MediaQuery);

  var info = {

    version: '1.0.6'

  };

  var sizes = {};

  var unionSizes = {};

  var Breakpoints = (window.Breakpoints = function() {

    for (

      var _len = arguments.length, args = Array(_len), _key = 0;

      _key < _len;

      _key++

    ) {

      args[_key] = arguments[_key];

    }

    Breakpoints.define.apply(Breakpoints, args);

  });

  Breakpoints.defaults = defaults;

  Breakpoints = util.extend(Breakpoints, {

    version: info.version,

    defined: false,

    define: function define(values) {

      var options =

        arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};

      if (this.defined) {

        this.destroy();

      }

      if (!values) {

        values = Breakpoints.defaults;

      }

      this.options = util.extend(options, {

        unit: 'px'

      });

      for (var size in values) {

        if (values.hasOwnProperty(size)) {

          this.set(size, values[size].min, values[size].max, this.options.unit);

        }

      }

      this.defined = true;

    },

    destroy: function destroy() {

      util.each(sizes, function(name, size) {

        size.destroy();

      });

      sizes = {};

      ChangeEvent.current = null;

    },

    is: function is(size) {

      var breakpoint = this.get(size);

      if (!breakpoint) {

        return null;

      }

      return breakpoint.isMatched();

    },

    all: function all() {

      var names = [];

      util.each(sizes, function(name) {

        names.push(name);

      });

      return names;

    },

    set: function set(name) {

      var min =

        arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;

      var max =

        arguments.length > 2 && arguments[2] !== undefined

          ? arguments[2]

          : Infinity;

      var unit =

        arguments.length > 3 && arguments[3] !== undefined

          ? arguments[3]

          : 'px';

      var size = this.get(name);

      if (size) {

        size.destroy();

      }

      sizes[name] = new Size(name, min, max, unit);

      return sizes[name];

    },

    get: function get(size) {

      if (sizes.hasOwnProperty(size)) {

        return sizes[size];

      }

      return null;

    },

    getUnion: function getUnion(sizes) {

      if (unionSizes.hasOwnProperty(sizes)) {

        return unionSizes[sizes];

      }

      unionSizes[sizes] = new UnionSize(sizes);

      return unionSizes[sizes];

    },

    getMin: function getMin(size) {

      var obj = this.get(size);

      if (obj) {

        return obj.min;

      }

      return null;

    },

    getMax: function getMax(size) {

      var obj = this.get(size);

      if (obj) {

        return obj.max;

      }

      return null;

    },

    current: function current() {

      return ChangeEvent.current;

    },

    getMedia: function getMedia(size) {

      var obj = this.get(size);

      if (obj) {

        return obj.media;

      }

      return null;

    },

    on: function on(sizes, types, data, fn) {

      var one =

        arguments.length > 4 && arguments[4] !== undefined

          ? arguments[4]

          : false;

      sizes = sizes.trim();

      if (sizes === 'change') {

        fn = data;

        data = types;

        return ChangeEvent.on(data, fn, one);

      }

      if (sizes.includes(' ')) {

        var union = this.getUnion(sizes);

        if (union) {

          union.on(types, data, fn, one);

        }

      } else {

        var size = this.get(sizes);

        if (size) {

          size.on(types, data, fn, one);

        }

      }

      return this;

    },

    one: function one(sizes, types, data, fn) {

      return this.on(sizes, types, data, fn, true);

    },

    off: function off(sizes, types, fn) {

      sizes = sizes.trim();

      if (sizes === 'change') {

        return ChangeEvent.off(types);

      }

      if (sizes.includes(' ')) {

        var union = this.getUnion(sizes);

        if (union) {

          union.off(types, fn);

        }

      } else {

        var size = this.get(sizes);

        if (size) {

          size.off(types, fn);

        }

      }

      return this;

    }

  });

  var Breakpoints$1 = Breakpoints;

  exports.default = Breakpoints$1;

});