materialize-sass 0.100.2.1 → 1.0.0.alpha1

data/assets/javascripts/materialize/parallax.js

@@ -0,0 +1,135 @@
+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; }; }();
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+(function ($) {
+  'use strict';
+
+  var _defaults = {};
+
+  var Parallax = function () {
+    function Parallax(el, options) {
+      _classCallCheck(this, Parallax);
+
+      // If exists, destroy and reinitialize
+      if (!!el.M_Parallax) {
+        el.M_Parallax.destroy();
+      }
+
+      this.el = el;
+      this.$el = $(el);
+      this.el.M_Parallax = this;
+
+      this.options = $.extend({}, Parallax.defaults, options);
+
+      this.$img = this.$el.find('img').first();
+      this._updateParallax();
+      this._setupEventHandlers();
+      this._setupStyles();
+
+      Parallax._parallaxes.push(this);
+    }
+
+    _createClass(Parallax, [{
+      key: 'destroy',
+
+
+      /**
+       * Teardown component
+       */
+      value: function destroy() {}
+    }, {
+      key: '_setupEventHandlers',
+      value: function _setupEventHandlers() {
+        this._handleImageLoadBound = this._handleImageLoad.bind(this);
+        this.$img[0].addEventListener('load', this._handleImageLoadBound);
+
+        if (Parallax._parallaxes.length === 0) {
+          Parallax._handleScrollThrottled = M.throttle(Parallax._handleScroll, 5);
+          window.addEventListener('scroll', Parallax._handleScrollThrottled);
+        }
+      }
+    }, {
+      key: '_setupStyles',
+      value: function _setupStyles() {
+        this.$img[0].style.opacity = 1;
+      }
+    }, {
+      key: '_handleImageLoad',
+      value: function _handleImageLoad() {
+        this._updateParallax();
+        this.$img.each(function () {
+          var el = this;
+          if (el.complete) $(el).trigger("load");
+        });
+      }
+    }, {
+      key: '_updateParallax',
+      value: function _updateParallax() {
+        var containerHeight = this.$el.height() > 0 ? this.el.parentNode.offsetHeight : 500;
+        var imgHeight = this.$img[0].offsetHeight;
+        var parallaxDist = imgHeight - containerHeight;
+        var bottom = this.$el.offset().top + containerHeight;
+        var top = this.$el.offset().top;
+        var scrollTop = M.getDocumentScrollTop();
+        var windowHeight = window.innerHeight;
+        var windowBottom = scrollTop + windowHeight;
+        var percentScrolled = (windowBottom - top) / (containerHeight + windowHeight);
+        var parallax = parallaxDist * percentScrolled;
+
+        if (bottom > scrollTop && top < scrollTop + windowHeight) {
+          this.$img[0].style.transform = 'translate3D(-50%, ' + parallax + 'px, 0)';
+        }
+      }
+    }], [{
+      key: 'init',
+      value: function init($els, options) {
+        var arr = [];
+        $els.each(function () {
+          arr.push(new Parallax(this, options));
+        });
+        return arr;
+      }
+
+      /**
+       * Get Instance
+       */
+
+    }, {
+      key: 'getInstance',
+      value: function getInstance(el) {
+        var domElem = !!el.jquery ? el[0] : el;
+        return domElem.M_Parallax;
+      }
+    }, {
+      key: '_handleScroll',
+      value: function _handleScroll() {
+        for (var i = 0; i < Parallax._parallaxes.length; i++) {
+          var parallaxInstance = Parallax._parallaxes[i];
+          parallaxInstance._updateParallax.call(parallaxInstance);
+        }
+      }
+    }, {
+      key: 'defaults',
+      get: function () {
+        return _defaults;
+      }
+    }]);
+
+    return Parallax;
+  }();
+
+  /**
+   * @static
+   * @memberof Parallax
+   */
+
+
+  Parallax._parallaxes = [];
+
+  M.Parallax = Parallax;
+
+  if (M.jQueryLoaded) {
+    M.initializeJqueryWrapper(Parallax, 'parallax', 'M_Parallax');
+  }
+})(cash);

data/assets/javascripts/materialize/pushpin.js

@@ -0,0 +1,158 @@
+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; }; }();
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+(function ($) {
+  'use strict';
+
+  var _defaults = {
+    top: 0,
+    bottom: Infinity,
+    offset: 0
+  };
+
+  /**
+   * @class
+   *
+   */
+
+  var Pushpin = function () {
+    /**
+     * Construct Pushpin instance
+     * @constructor
+     * @param {Element} el
+     * @param {Object} options
+     */
+    function Pushpin(el, options) {
+      _classCallCheck(this, Pushpin);
+
+      // If exists, destroy and reinitialize
+      if (!!el.M_Pushpin) {
+        el.M_Pushpin.destroy();
+      }
+
+      this.el = el;
+      this.$el = $(el);
+      this.el.M_Pushpin = this;
+
+      /**
+       * Options for the modal
+       * @member Pushpin#options
+       */
+      this.options = $.extend({}, Pushpin.defaults, options);
+
+      this.originalOffset = this.el.offsetTop;
+      Pushpin._pushpins.push(this);
+      this._setupEventHandlers();
+      this._updatePosition();
+    }
+
+    _createClass(Pushpin, [{
+      key: 'destroy',
+
+
+      /**
+       * Teardown component
+       */
+      value: function destroy() {
+        this.el.style.top = null;
+        this._removePinClasses();
+        this._removeEventHandlers();
+
+        // Remove pushpin Inst
+        var index = Pushpin._pushpins.indexOf(this);
+        Pushpin._pushpins.splice(index, 1);
+      }
+    }, {
+      key: '_setupEventHandlers',
+      value: function _setupEventHandlers() {
+        document.addEventListener('scroll', Pushpin._updateElements);
+      }
+    }, {
+      key: '_removeEventHandlers',
+      value: function _removeEventHandlers() {
+        document.removeEventListener('scroll', Pushpin._updateElements);
+      }
+    }, {
+      key: '_updatePosition',
+      value: function _updatePosition() {
+        var scrolled = M.getDocumentScrollTop() + this.options.offset;
+
+        if (this.options.top <= scrolled && this.options.bottom >= scrolled && !this.el.classList.contains('pinned')) {
+          this._removePinClasses();
+
+          this.el.style.top = this.options.offset + 'px';
+          this.el.classList.add('pinned');
+        }
+
+        // Add pin-top (when scrolled position is above top)
+        if (scrolled < this.options.top && !this.el.classList.contains('pin-top')) {
+          this._removePinClasses();
+          this.el.style.top = 0;
+          this.el.classList.add('pin-top');
+        }
+
+        // Add pin-bottom (when scrolled position is below bottom)
+        if (scrolled > this.options.bottom && !this.el.classList.contains('pin-bottom')) {
+          this._removePinClasses();
+          this.el.classList.add('pin-bottom');
+          this.el.style.top = this.options.bottom - this.originalOffset + 'px';
+        }
+      }
+    }, {
+      key: '_removePinClasses',
+      value: function _removePinClasses() {
+        this.el.classList.remove('pin-top', 'pinned', 'pin-bottom');
+      }
+    }], [{
+      key: 'init',
+      value: function init($els, options) {
+        var arr = [];
+        $els.each(function () {
+          arr.push(new Pushpin(this, options));
+        });
+        return arr;
+      }
+
+      /**
+       * Get Instance
+       */
+
+    }, {
+      key: 'getInstance',
+      value: function getInstance(el) {
+        var domElem = !!el.jquery ? el[0] : el;
+        return domElem.M_Pushpin;
+      }
+    }, {
+      key: '_updateElements',
+      value: function _updateElements() {
+        for (var elIndex in Pushpin._pushpins) {
+          var pInstance = Pushpin._pushpins[elIndex];
+          pInstance._updatePosition();
+        }
+      }
+    }, {
+      key: 'defaults',
+      get: function () {
+        return _defaults;
+      }
+    }]);
+
+    return Pushpin;
+  }();
+
+  /**
+   * @static
+   * @memberof Pushpin
+   */
+
+
+  Pushpin._pushpins = [];
+
+  M.Pushpin = Pushpin;
+
+  if (M.jQueryLoaded) {
+    M.initializeJqueryWrapper(Pushpin, 'pushpin', 'M_Pushpin');
+  }
+})(cash);

data/assets/javascripts/materialize/range.js

@@ -0,0 +1,305 @@
+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; }; }();
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+(function ($, Vel) {
+  'use strict';
+
+  var _defaults = {};
+
+  /**
+   * @class
+   *
+   */
+
+  var Range = function () {
+    /**
+     * Construct Range instance
+     * @constructor
+     * @param {Element} el
+     * @param {Object} options
+     */
+    function Range(el, options) {
+      _classCallCheck(this, Range);
+
+      // If exists, destroy and reinitialize
+      if (!!el.M_Range) {
+        el.M_Range.destroy();
+      }
+
+      this.el = el;
+      this.$el = $(el);
+      this.el.M_Range = this;
+
+      /**
+       * Options for the range
+       * @member Range#options
+       */
+      this.options = $.extend({}, Range.defaults, options);
+
+      this._mousedown = false;
+
+      // Setup
+      this._setupThumb();
+
+      this._setupEventHandlers();
+    }
+
+    _createClass(Range, [{
+      key: 'destroy',
+
+
+      /**
+       * Teardown component
+       */
+      value: function destroy() {
+        this._removeEventHandlers();
+        this._removeThumb();
+        this.el.M_Range = undefined;
+      }
+
+      /**
+       * Setup Event Handlers
+       */
+
+    }, {
+      key: '_setupEventHandlers',
+      value: function _setupEventHandlers() {
+        this._handleRangeChangeBound = this._handleRangeChange.bind(this);
+        this._handleRangeMousedownTouchstartBound = this._handleRangeMousedownTouchstart.bind(this);
+        this._handleRangeInputMousemoveTouchmoveBound = this._handleRangeInputMousemoveTouchmove.bind(this);
+        this._handleRangeMouseupTouchendBound = this._handleRangeMouseupTouchend.bind(this);
+        this._handleRangeBlurMouseoutTouchleaveBound = this._handleRangeBlurMouseoutTouchleave.bind(this);
+
+        this.el.addEventListener('change', this._handleRangeChangeBound);
+
+        this.el.addEventListener('mousedown', this._handleRangeMousedownTouchstartBound);
+        this.el.addEventListener('touchstart', this._handleRangeMousedownTouchstartBound);
+
+        this.el.addEventListener('input', this._handleRangeInputMousemoveTouchmoveBound);
+        this.el.addEventListener('mousemove', this._handleRangeInputMousemoveTouchmoveBound);
+        this.el.addEventListener('touchmove', this._handleRangeInputMousemoveTouchmoveBound);
+
+        this.el.addEventListener('mouseup', this._handleRangeMouseupTouchendBound);
+        this.el.addEventListener('touchend', this._handleRangeMouseupTouchendBound);
+
+        this.el.addEventListener('blur', this._handleRangeBlurMouseoutTouchleaveBound);
+        this.el.addEventListener('mouseout', this._handleRangeBlurMouseoutTouchleaveBound);
+        this.el.addEventListener('touchleave', this._handleRangeBlurMouseoutTouchleaveBound);
+      }
+
+      /**
+       * Remove Event Handlers
+       */
+
+    }, {
+      key: '_removeEventHandlers',
+      value: function _removeEventHandlers() {
+        this.el.removeEventListener('change', this._handleRangeChangeBound);
+
+        this.el.removeEventListener('mousedown', this._handleRangeMousedownTouchstartBound);
+        this.el.removeEventListener('touchstart', this._handleRangeMousedownTouchstartBound);
+
+        this.el.removeEventListener('input', this._handleRangeInputMousemoveTouchmoveBound);
+        this.el.removeEventListener('mousemove', this._handleRangeInputMousemoveTouchmoveBound);
+        this.el.removeEventListener('touchmove', this._handleRangeInputMousemoveTouchmoveBound);
+
+        this.el.removeEventListener('mouseup', this._handleRangeMouseupTouchendBound);
+        this.el.removeEventListener('touchend', this._handleRangeMouseupTouchendBound);
+
+        this.el.removeEventListener('blur', this._handleRangeBlurMouseoutTouchleaveBound);
+        this.el.removeEventListener('mouseout', this._handleRangeBlurMouseoutTouchleaveBound);
+        this.el.removeEventListener('touchleave', this._handleRangeBlurMouseoutTouchleaveBound);
+      }
+
+      /**
+       * Handle Range Change
+       * @param {Event} e
+       */
+
+    }, {
+      key: '_handleRangeChange',
+      value: function _handleRangeChange() {
+        $(this.value).html(this.$el.val());
+
+        if (!$(this.thumb).hasClass('active')) {
+          this._showRangeBubble();
+        }
+
+        var offsetLeft = this._calcRangeOffset();
+        $(this.thumb).addClass('active').css('left', offsetLeft + 'px');
+      }
+
+      /**
+       * Handle Range Mousedown and Touchstart
+       * @param {Event} e
+       */
+
+    }, {
+      key: '_handleRangeMousedownTouchstart',
+      value: function _handleRangeMousedownTouchstart(e) {
+        // Set indicator value
+        $(this.value).html(this.$el.val());
+
+        this._mousedown = true;
+        this.$el.addClass('active');
+
+        if (!$(this.thumb).hasClass('active')) {
+          this._showRangeBubble();
+        }
+
+        if (e.type !== 'input') {
+          var offsetLeft = this._calcRangeOffset();
+          $(this.thumb).addClass('active').css('left', offsetLeft + 'px');
+        }
+      }
+
+      /**
+       * Handle Range Input, Mousemove and Touchmove
+       */
+
+    }, {
+      key: '_handleRangeInputMousemoveTouchmove',
+      value: function _handleRangeInputMousemoveTouchmove() {
+        if (this._mousedown) {
+          if (!$(this.thumb).hasClass('active')) {
+            this._showRangeBubble();
+          }
+
+          var offsetLeft = this._calcRangeOffset();
+          $(this.thumb).addClass('active').css('left', offsetLeft + 'px');
+          $(this.value).html(this.$el.val());
+        }
+      }
+
+      /**
+       * Handle Range Mouseup and Touchend
+       */
+
+    }, {
+      key: '_handleRangeMouseupTouchend',
+      value: function _handleRangeMouseupTouchend() {
+        this._mousedown = false;
+        this.$el.removeClass('active');
+      }
+
+      /**
+       * Handle Range Blur, Mouseout and Touchleave
+       */
+
+    }, {
+      key: '_handleRangeBlurMouseoutTouchleave',
+      value: function _handleRangeBlurMouseoutTouchleave() {
+        if (!this._mousedown) {
+          var paddingLeft = parseInt(this.$el.css('padding-left'));
+          var marginLeft = 7 + paddingLeft + 'px';
+
+          if ($(this.thumb).hasClass('active')) {
+            Vel(this.thumb, 'stop');
+            Vel(this.thumb, {
+              height: '0px',
+              width: '0px',
+              top: '10px',
+              marginLeft: marginLeft
+            }, { duration: 100 });
+          }
+          $(this.thumb).removeClass('active');
+        }
+      }
+
+      /**
+       * Setup dropdown
+       */
+
+    }, {
+      key: '_setupThumb',
+      value: function _setupThumb() {
+        this.thumb = document.createElement('span');
+        this.value = document.createElement('span');
+        $(this.thumb).addClass('thumb');
+        $(this.value).addClass('value');
+        $(this.thumb).append(this.value);
+        this.$el.after(this.thumb);
+      }
+
+      /**
+       * Remove dropdown
+       */
+
+    }, {
+      key: '_removeThumb',
+      value: function _removeThumb() {
+        $(this.thumb).remove();
+      }
+
+      /**
+       * morph thumb into bubble
+       */
+
+    }, {
+      key: '_showRangeBubble',
+      value: function _showRangeBubble() {
+        var paddingLeft = parseInt($(this.thumb).parent().css('padding-left'));
+        var marginLeft = -7 + paddingLeft + 'px'; // TODO: fix magic number?
+        Vel(this.thumb, {
+          height: "30px",
+          width: "30px",
+          top: "-30px",
+          marginLeft: marginLeft
+        }, { duration: 300, easing: 'easeOutExpo' });
+      }
+
+      /**
+       * Calculate the offset of the thumb
+       * @return {Number}  offset in pixels
+       */
+
+    }, {
+      key: '_calcRangeOffset',
+      value: function _calcRangeOffset() {
+        var width = this.$el.width() - 15;
+        var max = parseFloat(this.$el.attr('max'));
+        var min = parseFloat(this.$el.attr('min'));
+        var percent = (parseFloat(this.$el.val()) - min) / (max - min);
+        return percent * width;
+      }
+    }], [{
+      key: 'init',
+      value: function init($els, options) {
+        var arr = [];
+        $els.each(function () {
+          if (!$(this).hasClass('browser-default')) {
+            arr.push(new Range(this, options));
+          }
+        });
+        return arr;
+      }
+
+      /**
+       * Get Instance
+       */
+
+    }, {
+      key: 'getInstance',
+      value: function getInstance(el) {
+        var domElem = !!el.jquery ? el[0] : el;
+        return domElem.M_Range;
+      }
+    }, {
+      key: 'defaults',
+      get: function () {
+        return _defaults;
+      }
+    }]);
+
+    return Range;
+  }();
+
+  M.Range = Range;
+
+  if (M.jQueryLoaded) {
+    M.initializeJqueryWrapper(Range, 'range', 'M_Range');
+  }
+
+  Range.init($('input[type=range'));
+})(cash, M.Vel);