boletia_ui 0.1.1

data/vendor/assets/boletia_ui/javascripts/boletia-ui/boletia-ui-components.js

@@ -0,0 +1,117 @@
+$(document).ready(function() {
+
+
+	//Tooltip Initialize
+
+  $('.js-tooltip--top').tooltipster({
+		theme: 'o-tooltip',
+		position: 'top',
+		iconDesktop: true
+	});
+
+
+
+ 	$('.js-tooltip--right').tooltipster({
+		theme: 'o-tooltip',
+		position: 'right',
+		iconDesktop: true
+	});
+
+
+	$('.js-tooltip--bottom').tooltipster({
+		theme: 'o-tooltip',
+		position: 'bottom',
+		iconDesktop: true
+	});
+
+
+	$('.js-tooltip--left').tooltipster({
+		theme: 'o-tooltip',
+		position: 'left',
+		iconDesktop: true
+	});
+
+
+
+	//Tooltip No Icons
+
+  $('.js-tooltip__no-icon--top').tooltipster({
+		theme: 'o-tooltip',
+		position: 'top'
+	});
+
+
+
+ 	$('.js-tooltip__no-icon--right').tooltipster({
+		theme: 'o-tooltip',
+		position: 'right'
+	});
+
+
+	$('.js-tooltip__no-icon--bottom').tooltipster({
+		theme: 'o-tooltip',
+		position: 'bottom'
+	});
+
+
+	$('.js-tooltip__no-icon--left').tooltipster({
+		theme: 'o-tooltip',
+		position: 'left'
+	});
+
+
+
+
+	$('.js-tooltip__badge').tooltipster({
+		theme: 'o-tooltip',
+		position: 'top'
+	});
+
+
+	//Date Picker
+
+	$( ".js-datepicker" ).datepicker();
+
+
+
+	//Auto Complete
+
+	var availableEvents = [
+      "Spartan Race Monterrey",
+      "The Color Run",
+      "Festival de Bahidora",
+      "NRMl",
+      "Tough Mudder Monterrey",
+      "Badwater Ultramaraton",
+      "Carrera Brutal",
+      "Epic Queen: Monterrey Chapter",
+      "Startup Grind",
+      "WWE Raw"
+    ];
+
+
+  $( "#js-header-search__input" ).autocomplete({
+    source: availableEvents,
+    position: { my : "left top", at: "left top" }
+  }).autocomplete("widget").addClass("o-header-search__autocomplete");
+
+
+  // MODALS
+
+
+  $('.js-modal-box__action').magnificPopup({
+  	type:'inline',
+  	midClick: true,
+  	closeBtnInside:true   
+	});
+
+	//Alerts
+
+	$(".o-system-message__close").on('click', function(event) {
+
+		$(event.target).closest(".o-system-message").fadeOut("slow");
+  	
+	});
+
+
+ });

data/vendor/assets/boletia_ui/javascripts/boletia-ui/classie.js

@@ -0,0 +1,80 @@
+/*!
+ * classie - class helper functions
+ * from bonzo https://github.com/ded/bonzo
+ * 
+ * classie.has( elem, 'my-class' ) -> true/false
+ * classie.add( elem, 'my-new-class' )
+ * classie.remove( elem, 'my-unwanted-class' )
+ * classie.toggle( elem, 'my-class' )
+ */
+
+/*jshint browser: true, strict: true, undef: true */
+/*global define: false */
+
+( function( window ) {
+
+'use strict';
+
+// class helper functions from bonzo https://github.com/ded/bonzo
+
+function classReg( className ) {
+  return new RegExp("(^|\\s+)" + className + "(\\s+|$)");
+}
+
+// classList support for class management
+// altho to be fair, the api sucks because it won't accept multiple classes at once
+var hasClass, addClass, removeClass;
+
+if ( 'classList' in document.documentElement ) {
+  hasClass = function( elem, c ) {
+    return elem.classList.contains( c );
+  };
+  addClass = function( elem, c ) {
+    elem.classList.add( c );
+  };
+  removeClass = function( elem, c ) {
+    elem.classList.remove( c );
+  };
+}
+else {
+  hasClass = function( elem, c ) {
+    return classReg( c ).test( elem.className );
+  };
+  addClass = function( elem, c ) {
+    if ( !hasClass( elem, c ) ) {
+      elem.className = elem.className + ' ' + c;
+    }
+  };
+  removeClass = function( elem, c ) {
+    elem.className = elem.className.replace( classReg( c ), ' ' );
+  };
+}
+
+function toggleClass( elem, c ) {
+  var fn = hasClass( elem, c ) ? removeClass : addClass;
+  fn( elem, c );
+}
+
+var classie = {
+  // full names
+  hasClass: hasClass,
+  addClass: addClass,
+  removeClass: removeClass,
+  toggleClass: toggleClass,
+  // short names
+  has: hasClass,
+  add: addClass,
+  remove: removeClass,
+  toggle: toggleClass
+};
+
+// transport
+if ( typeof define === 'function' && define.amd ) {
+  // AMD
+  define( classie );
+} else {
+  // browser global
+  window.classie = classie;
+}
+
+})( window );

data/vendor/assets/boletia_ui/javascripts/boletia-ui/select_fx.js

@@ -0,0 +1,335 @@
+// SELECT FX //
+
+/**
+ * selectFx.js v1.0.0
+ * http://www.codrops.com
+ *
+ * Licensed under the MIT license.
+ * http://www.opensource.org/licenses/mit-license.php
+ * 
+ * Copyright 2014, Codrops
+ * http://www.codrops.com
+ */
+;( function( window ) {
+  
+  'use strict';
+
+  /**
+   * based on from https://github.com/inuyaksa/jquery.nicescroll/blob/master/jquery.nicescroll.js
+   */
+  function hasParent( e, p ) {
+    if (!e) return false;
+    var el = e.target||e.srcElement||e||false;
+    while (el && el != p) {
+      el = el.parentNode||false;
+    }
+    return (el!==false);
+  };
+  
+  /**
+   * extend obj function
+   */
+  function extend( a, b ) {
+    for( var key in b ) { 
+      if( b.hasOwnProperty( key ) ) {
+        a[key] = b[key];
+      }
+    }
+    return a;
+  }
+
+  /**
+   * SelectFx function
+   */
+  function SelectFx( el, options ) {  
+    this.el = el;
+    this.options = extend( {}, this.options );
+    extend( this.options, options );
+    this._init();
+  }
+
+  /**
+   * SelectFx options
+   */
+  SelectFx.prototype.options = {
+    // if true all the links will open in a new tab.
+    // if we want to be redirected when we click an option, we need to define a data-link attr on the option of the native select element
+    newTab : true,
+    // when opening the select element, the default placeholder (if any) is shown
+    stickyPlaceholder : true,
+    // callback when changing the value
+    onChange : function( val ) { return false; }
+  }
+
+  /**
+   * init function
+   * initialize and cache some vars
+   */
+  SelectFx.prototype._init = function() {
+    // check if we are using a placeholder for the native select box
+    // we assume the placeholder is disabled and selected by default
+    var selectedOpt = this.el.querySelector( 'option[selected]' );
+    this.hasDefaultPlaceholder = selectedOpt && selectedOpt.disabled;
+
+    // get selected option (either the first option with attr selected or just the first option)
+    this.selectedOpt = selectedOpt || this.el.querySelector( 'option' );
+
+    // create structure
+    this._createSelectEl();
+
+    // all options
+    this.selOpts = [].slice.call( this.selEl.querySelectorAll( 'li[data-option]' ) );
+    
+    // total options
+    this.selOptsCount = this.selOpts.length;
+    
+    // current index
+    this.current = this.selOpts.indexOf( this.selEl.querySelector( 'li.js-custom-selected' ) ) || -1;
+    
+    // placeholder elem
+    this.selPlaceholder = this.selEl.querySelector( 'span.cs-placeholder' );
+
+    // init events
+    this._initEvents();
+  }
+
+  /**
+   * creates the structure for the select element
+   */
+  SelectFx.prototype._createSelectEl = function() {
+    var self = this, options = '', createOptionHTML = function(el) {
+      var optclass = '', classes = '', link = '';
+
+      if( el.selectedOpt && !this.foundSelected && !this.hasDefaultPlaceholder ) {
+        classes += 'js-custom-selected ';
+        this.foundSelected = true;
+      }
+      // extra classes
+      if( el.getAttribute( 'data-class' ) ) {
+        classes += el.getAttribute( 'data-class' );
+      }
+      // link options
+      if( el.getAttribute( 'data-link' ) ) {
+        link = 'data-link=' + el.getAttribute( 'data-link' );
+      }
+
+      if( classes !== '' ) {
+        optclass = 'class="' + classes + '" ';
+      }
+
+      return '<li ' + optclass + link + ' data-option data-value="' + el.value + '"><span>' + el.textContent + '</span></li>';
+    };
+
+    [].slice.call( this.el.children ).forEach( function(el) {
+      if( el.disabled ) { return; }
+
+      var tag = el.tagName.toLowerCase();
+
+      if( tag === 'option' ) {
+        options += createOptionHTML(el);
+      }
+      else if( tag === 'optgroup' ) {
+        options += '<li class="cs-optgroup"><span>' + el.label + '</span><ul>';
+        [].slice.call( el.children ).forEach( function(opt) {
+          options += createOptionHTML(opt);
+        } );
+        options += '</ul></li>';
+      }
+    } );
+
+    var opts_el = '<div class="cs-options"><ul>' + options + '</ul></div>';
+    this.selEl = document.createElement( 'div' );
+    this.selEl.className = this.el.className;
+    this.selEl.tabIndex = this.el.tabIndex;
+    this.selEl.innerHTML = '<span class="cs-placeholder">' + this.selectedOpt.textContent + '</span>' + opts_el;
+    this.el.parentNode.appendChild( this.selEl );
+    this.selEl.appendChild( this.el );
+  }
+
+  /**
+   * initialize the events
+   */
+  SelectFx.prototype._initEvents = function() {
+    var self = this;
+
+    // open/close select
+    this.selPlaceholder.addEventListener( 'click', function() {
+      self._toggleSelect();
+    } );
+
+    // clicking the options
+    this.selOpts.forEach( function(opt, idx) {
+      opt.addEventListener( 'click', function() {
+        self.current = idx;
+        self._changeOption();
+        // close select elem
+        self._toggleSelect();
+      } );
+    } );
+
+    // close the select element if the target it´s not the select element or one of its descendants..
+    document.addEventListener( 'click', function(ev) {
+      var target = ev.target;
+      if( self._isOpen() && target !== self.selEl && !hasParent( target, self.selEl ) ) {
+        self._toggleSelect();
+      }
+    } );
+
+    // keyboard navigation events
+    this.selEl.addEventListener( 'keydown', function( ev ) {
+      var keyCode = ev.keyCode || ev.which;
+
+      switch (keyCode) {
+        // up key
+        case 38:
+          ev.preventDefault();
+          self._navigateOpts('prev');
+          break;
+        // down key
+        case 40:
+          ev.preventDefault();
+          self._navigateOpts('next');
+          break;
+        // space key
+        case 32:
+          ev.preventDefault();
+          if( self._isOpen() && typeof self.preSelCurrent != 'undefined' && self.preSelCurrent !== -1 ) {
+            self._changeOption();
+          }
+          self._toggleSelect();
+          break;
+        // enter key
+        case 13:
+          ev.preventDefault();
+          if( self._isOpen() && typeof self.preSelCurrent != 'undefined' && self.preSelCurrent !== -1 ) {
+            self._changeOption();
+            self._toggleSelect();
+          }
+          break;
+        // esc key
+        case 27:
+          ev.preventDefault();
+          if( self._isOpen() ) {
+            self._toggleSelect();
+          }
+          break;
+      }
+    } );
+  }
+
+  /**
+   * navigate with up/dpwn keys
+   */
+  SelectFx.prototype._navigateOpts = function(dir) {
+    if( !this._isOpen() ) {
+      this._toggleSelect();
+    }
+
+    var tmpcurrent = typeof this.preSelCurrent != 'undefined' && this.preSelCurrent !== -1 ? this.preSelCurrent : this.current;
+    
+    if( dir === 'prev' && tmpcurrent > 0 || dir === 'next' && tmpcurrent < this.selOptsCount - 1 ) {
+      // save pre selected current - if we click on option, or press enter, or press space this is going to be the index of the current option
+      this.preSelCurrent = dir === 'next' ? tmpcurrent + 1 : tmpcurrent - 1;
+      // remove focus class if any..
+      this._removeFocus();
+      // add class focus - track which option we are navigating
+      classie.add( this.selOpts[this.preSelCurrent], 'cs-focus' );
+    }
+  }
+
+  /**
+   * open/close select
+   * when opened show the default placeholder if any
+   */
+  SelectFx.prototype._toggleSelect = function() {
+    // remove focus class if any..
+    this._removeFocus();
+    
+    if( this._isOpen() ) {
+      if( this.current !== -1 ) {
+        // update placeholder text
+        this.selPlaceholder.textContent = this.selOpts[ this.current ].textContent;
+      }
+      classie.remove( this.selEl, 'cs-active' );
+    }
+    else {
+      if( this.hasDefaultPlaceholder && this.options.stickyPlaceholder ) {
+        // everytime we open we wanna see the default placeholder text
+        this.selPlaceholder.textContent = this.selectedOpt.textContent;
+      }
+      classie.add( this.selEl, 'cs-active' );
+    }
+  }
+
+  /**
+   * change option - the new value is set
+   */
+  SelectFx.prototype._changeOption = function() {
+    // if pre selected current (if we navigate with the keyboard)...
+    if( typeof this.preSelCurrent != 'undefined' && this.preSelCurrent !== -1 ) {
+      this.current = this.preSelCurrent;
+      this.preSelCurrent = -1;
+    }
+
+    // current option
+    var opt = this.selOpts[ this.current ];
+
+    // update current selected value
+    this.selPlaceholder.textContent = opt.textContent;
+    
+    // change native select element´s value
+    this.el.value = opt.getAttribute( 'data-value' );
+
+    // remove class js-custom-selected from old selected option and add it to current selected option
+    var oldOpt = this.selEl.querySelector( 'li.js-custom-selected' );
+    if( oldOpt ) {
+      classie.remove( oldOpt, 'js-custom-selected' );
+    }
+    classie.add( opt, 'js-custom-selected' );
+
+    // if there´s a link defined
+    if( opt.getAttribute( 'data-link' ) ) {
+      // open in new tab?
+      if( this.options.newTab ) {
+        window.open( opt.getAttribute( 'data-link' ), '_blank' );
+      }
+      else {
+        window.location = opt.getAttribute( 'data-link' );
+      }
+    }
+
+    // callback
+    this.options.onChange( this.el.value );
+  }
+
+  /**
+   * returns true if select element is opened
+   */
+  SelectFx.prototype._isOpen = function(opt) {
+    return classie.has( this.selEl, 'cs-active' );
+  }
+
+  /**
+   * removes the focus class from the option
+   */
+  SelectFx.prototype._removeFocus = function(opt) {
+    var focusEl = this.selEl.querySelector( 'li.cs-focus' )
+    if( focusEl ) {
+      classie.remove( focusEl, 'cs-focus' );
+    }
+  }
+
+  /**
+   * add to global namespace
+   */
+  window.SelectFx = SelectFx;
+
+} )( window );
+
+
+
+(function() {
+    [].slice.call( document.querySelectorAll( 'select.js-custom-select' ) ).forEach( function(el) {  
+        new SelectFx(el);
+   } );
+  })();

data/vendor/assets/boletia_ui/javascripts/charts/Chart.Legend.js

@@ -0,0 +1,56 @@
+function legend(parent, data) {
+    legend(parent, data, null);
+}
+
+function legend(parent, data, chart) {
+    parent.className = 'o-chart-legend';
+    var datas = data.hasOwnProperty('datasets') ? data.datasets : data;
+
+    // remove possible children of the parent
+    while(parent.hasChildNodes()) {
+        parent.removeChild(parent.lastChild);
+    }
+
+    var show = chart ? showTooltip : noop;
+    datas.forEach(function(d, i) {
+        //span to div: legend appears to all element (color-sample and text-node)
+        var title = document.createElement('div');
+        title.className = 'o-chart-legend__title';
+        parent.appendChild(title);
+
+        var colorSample = document.createElement('div');
+        colorSample.className = 'o-chart-legend__color-sample';
+        colorSample.style.backgroundColor = d.hasOwnProperty('strokeColor') ? d.strokeColor : d.color;
+        colorSample.style.borderColor = d.hasOwnProperty('fillColor') ? d.fillColor : d.color;
+        title.appendChild(colorSample);
+
+        var text = document.createTextNode(d.label);
+        text.className = 'text-node';
+        title.appendChild(text);
+
+        show(chart, title, i);
+    });
+}
+
+//add events to legend that show tool tips on chart
+function showTooltip(chart, elem, indexChartSegment){
+    var helpers = Chart.helpers;
+
+    var segments = chart.segments;
+    //Only chart with segments
+    if(typeof segments != 'undefined'){
+        helpers.addEvent(elem, 'mouseover', function(){
+            var segment = segments[indexChartSegment];
+            segment.save();
+            segment.fillColor = segment.highlightColor;
+            chart.showTooltip([segment]);
+            segment.restore();
+        });
+
+        helpers.addEvent(elem, 'mouseout', function(){
+            chart.draw();
+        });
+    }
+}
+
+function noop() {}