ratchet_design 0.1.0

data/app/assets/javascripts/ratchet/shim/classlist.js

@@ -0,0 +1,234 @@
+/**
+ * ClassList
+ * Cross-browser full element.classList implementation
+ * @source http://purl.eligrey.com/github/classList.js/blob/master/classList.js
+ * @author Eli Grey - http://eligrey.com
+ * @license MIT
+ **/
+
+if ( 'document' in self ) {
+
+  // Full polyfill for browsers with no classList support
+  if ( !( 'classList' in document.createElement( '_' ) ) ) {
+
+    ( function( view ) {
+
+    'use strict';
+
+    if ( !( 'Element' in view ) ) return;
+
+    var
+      classListProp = 'classList',
+      protoProp     = 'prototype',
+      elemCtrProto  = view.Element[ protoProp ],
+      objCtr        = Object,
+
+      strTrim = String[ protoProp ].trim || function() {
+        return this.replace( /^\s+|\s+$/g, '' );
+      },
+
+      arrIndexOf = Array[ protoProp ].indexOf || function( item ) {
+        for ( var i = 0; i < this.length; i++ ) {
+          if ( i in this && this[ i ] === item ) {
+            return i;
+          }
+        }
+        return -1;
+      },
+
+      DOMEx = function( type, message ) {
+        this.name    = type;
+        this.code    = DOMException[ type ];
+        this.message = message;
+      },
+
+      checkTokenAndGetIndex = function( classList, token ) {
+        if ( token === '' ) {
+          throw new DOMEx(
+            'SYNTAX_ERR',
+            'An invalid or illegal string was specified'
+          );
+        }
+        if ( /\s/.test( token ) ) {
+          throw new DOMEx(
+            'INVALID_CHARACTER_ERR',
+            'String contains an invalid character'
+          );
+        }
+        return arrIndexOf.call( classList, token );
+      },
+
+      ClassList = function( elem ) {
+        var trimmedClasses = strTrim.call( elem.getAttribute( 'class' ) || '' ),
+            classes = trimmedClasses ? trimmedClasses.split( /\s+/ ) : [];
+
+        for ( var i = 0; i < classes.length; i++ ) {
+          this.push( classes[ i ] );
+        }
+
+        this._updateClassName = function() {
+          elem.setAttribute( 'class', this.toString() );
+        };
+      },
+
+      classListProto = ClassList[ protoProp ] = [],
+
+      classListGetter = function() {
+        return new ClassList( this );
+      };
+
+    DOMEx[ protoProp ] = Error[ protoProp ];
+
+    classListProto.item = function( i ) {
+      return this[ i ] || null;
+    };
+
+    classListProto.contains = function( token ) {
+      token += '';
+      return checkTokenAndGetIndex( this, token ) !== -1;
+    };
+
+    classListProto.add = function() {
+      var
+        tokens  = arguments,
+        iter    = 0,
+        len     = tokens.length,
+        updated = false,
+        token;
+
+      do {
+        token = tokens[ iter ] + '';
+        if ( checkTokenAndGetIndex( this, token ) === -1 ) {
+          this.push( token );
+          updated = true;
+        }
+      }
+
+      while ( ++iter < len );
+
+      if ( updated ) {
+        this._updateClassName();
+      }
+    };
+
+    classListProto.remove = function() {
+      var
+        tokens  = arguments,
+        iter    = 0,
+        len     = tokens.length,
+        updated = false,
+        token,
+        index;
+
+      do {
+        token = tokens[ iter ] + '';
+        index = checkTokenAndGetIndex( this, token );
+
+        while ( index !== -1 ) {
+          this.splice( index, 1 );
+          updated = true;
+          index = checkTokenAndGetIndex( this, token );
+        }
+      }
+
+      while ( ++iter < len );
+
+      if ( updated ) {
+        this._updateClassName();
+      }
+    };
+
+    classListProto.toggle = function( token, force ) {
+      token += '';
+
+      var
+        result = this.contains( token ),
+        method = result ? force !== true && 'remove' : force !== false && 'add';
+
+      if ( method ) {
+        this[ method ]( token );
+      }
+
+      if ( force === true || force === false ) {
+        return force;
+      } else {
+        return !result;
+      }
+    };
+
+    classListProto.toString = function() {
+      return this.join( ' ' );
+    };
+
+    if ( objCtr.defineProperty ) {
+      var classListPropDesc = {
+          get          : classListGetter,
+          enumerable   : true,
+          configurable : true
+      };
+
+      try {
+        objCtr.defineProperty( elemCtrProto, classListProp, classListPropDesc );
+      }
+
+      catch ( ex ) {
+        if ( ex.number === -0x7FF5EC54 ) {
+          classListPropDesc.enumerable = false;
+          objCtr.defineProperty( elemCtrProto, classListProp, classListPropDesc );
+        }
+      }
+
+    } else if ( objCtr[ protoProp ].__defineGetter__ ) {
+      elemCtrProto.__defineGetter__( classListProp, classListGetter );
+    }
+
+    }( self ));
+
+  } else {
+
+    ( function() {
+
+      'use strict';
+
+      var testElement = document.createElement( '_' );
+
+      testElement.classList.add( 'c1', 'c2' );
+
+      if ( !testElement.classList.contains( 'c2' ) ) {
+        var createMethod = function( method ) {
+          var original = DOMTokenList.prototype[ method ];
+
+          DOMTokenList.prototype[ method ] = function( token ) {
+            var i, len = arguments.length;
+
+            for ( i = 0; i < len; i++ ) {
+              token = arguments[ i ];
+              original.call( this, token );
+            }
+          };
+        };
+        createMethod( 'add' );
+        createMethod( 'remove' );
+      }
+
+      testElement.classList.toggle( 'c3', false );
+
+      if ( testElement.classList.contains( 'c3' ) ) {
+        var _toggle = DOMTokenList.prototype.toggle;
+
+        DOMTokenList.prototype.toggle = function( token, force ) {
+          if ( 1 in arguments && !this.contains( token ) === !force ) {
+            return force;
+          } else {
+            return _toggle.call( this, token );
+          }
+        };
+
+      }
+
+      testElement = null;
+
+    }());
+
+  }
+}

data/app/assets/javascripts/ratchet/shim/object.assign.js

@@ -0,0 +1,30 @@
+/**
+ * Object.assign polyfill
+ * Cross-browser full Object.assign implementation
+ * @source https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/assign#Polyfill
+ * @license MIT
+ **/
+
+if ( typeof Object.assign != 'function' ) {
+  ( function() {
+    Object.assign = function( target ) {
+      'use strict';
+      if ( target === undefined || target === null ) {
+        throw new TypeError( 'Cannot convert undefined or null to object' );
+      }
+
+      var output = Object( target );
+      for ( var index = 1; index < arguments.length; index++ ) {
+        var source = arguments[ index ];
+        if ( source !== undefined && source !== null ) {
+          for ( var nextKey in source ) {
+            if ( Object.prototype.hasOwnProperty.call( source, nextKey ) ) {
+              output[ nextKey ] = source[ nextKey ];
+            }
+          }
+        }
+      }
+      return output;
+    };
+  })();
+}

data/app/assets/javascripts/ratchet/utility/compile_data.js

@@ -0,0 +1,32 @@
+/**
+ * CompileData 0.0.1
+ * Compile input data from a given parent element
+ * @author Kyle Foster (@hkfoster)
+ * @license MIT
+ **/
+
+// Public API function
+var compileData = function( parent ) {
+
+  // Scoped variables
+  var formData  = new FormData(),
+      allFields = parent.querySelectorAll( 'input:not([type=submit])' );
+
+  // Loop over fields
+  for ( var i = 0; i < allFields.length; i++ ) {
+
+    // Uncomment for testing
+    // console.log( 'Name: ' + allFields[ i ].name + '\n' + 'Value: ' + allFields[ i ].value );
+
+    // And append their name/value to new formData object
+    formData.append( allFields[ i ].name, allFields[ i ].value );
+
+  }
+
+  // Then return said formData object
+  return formData;
+
+};
+
+// Public API
+module.exports = compileData;

data/app/assets/javascripts/ratchet/utility/from_top.js

@@ -0,0 +1,14 @@
+/**
+ * FromTop 0.0.1
+ * Find element’s distance from top of document
+ * @author Kyle Foster (@hkfoster)
+ * @license MIT
+ **/
+
+// Public API function
+var fromTop = function( elem ) {
+  return Math.round( elem.getBoundingClientRect().top + window.pageYOffset );
+};
+
+// Public API
+module.exports = fromTop;

data/app/assets/javascripts/ratchet/utility/full_stop.js

@@ -0,0 +1,55 @@
+/**
+ * FullStop 0.0.2
+ * Prevent CSS transitions from occurring during a window resize
+ * @author Kyle Foster (@hkfoster)
+ * @license MIT
+ **/
+
+// Dependencies
+var throttle = require( '../utility/throttle' ),
+    timeout  = require( '../utility/timeout' );
+
+// Public API function
+var fullStop = function( settings ) {
+
+  // Overridable defaults
+  var defaults = {
+    resizeDelay : 250,
+    resizeClass : 'no-transitions'
+  };
+
+  // Scoped variables
+  var options = Object.assign( {}, defaults, settings ),
+      docBody = document.body,
+      resizeTimer;
+
+  // Resize handler function
+  function resizeHandler() {
+
+    // Clear timer (if it exists)
+    if ( resizeTimer ) timeout.clear( resizeTimer );
+
+    // Add body class while resizing
+    docBody.classList.add( options.resizeClass );
+
+    // Check to see if resize is over
+    resizeTimer = timeout.set( function() {
+
+      // And remove body class upon completion
+      docBody.classList.remove( options.resizeClass );
+
+    // Delay firing function based on argument passed
+    }, options.resizeDelay );
+
+  }
+
+  // Resize throttle function init
+  throttle( 'resize', 'optimizedResize' );
+
+  // Resize function listener
+  window.addEventListener( 'optimizedResize', resizeHandler, false );
+
+};
+
+// Public API
+module.exports = fullStop;

data/app/assets/javascripts/ratchet/utility/get_closest.js

@@ -0,0 +1,20 @@
+/**
+ * GetClosest 0.0.1
+ * Get closest DOM element up the tree that matches a given selector
+ * @author Kyle Foster (@hkfoster)
+ * @license MIT
+ **/
+
+// Dependencies
+var matches = require( './matches' );
+
+// Public API function
+var getClosest = function ( elem, selector ) {
+  for ( ; elem && elem !== document; elem = elem.parentNode ) {
+    if ( matches( elem, selector ) ) return elem;
+  }
+  return false;
+};
+
+// Public API
+module.exports = getClosest;

data/app/assets/javascripts/ratchet/utility/get_next.js

@@ -0,0 +1,17 @@
+/**
+ * GetNext 0.0.1
+ * Get next DOM element that matches a given selector
+ * @author Kyle Foster (@hkfoster)
+ * @license MIT
+ **/
+
+// Public API function
+var getNext = function( elem, selector ) {
+  for ( ; elem && elem !== document; elem = elem.parentNode ) {
+    if ( elem.querySelector( selector ) ) return elem.querySelector( selector );
+  }
+  return false;
+};
+
+// Public API
+module.exports = getNext;

data/app/assets/javascripts/ratchet/utility/load_font.js

@@ -0,0 +1,72 @@
+/**
+ * LoadFont 0.0.1
+ * A font loader that leverages LocalStorage
+ * @author Adam Beres-Deak (@bdadam) & Kyle Foster (@hkfoster)
+ * @source https://github.com/bdadam/OptimizedWebfontLoading
+ * @license MIT
+ **/
+
+// Dependencies - https://github.com/filamentgroup/woff2-feature-test
+var supportsWoff2 = ( function( win ) {
+  if ( !( "FontFace" in win ) ) return false;
+  var f = new FontFace( 't', 'url( "data:application/font-woff2;base64,d09GMgABAAAAAAIkAAoAAAAABVwAAAHcAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAABlYAgloKLEoBNgIkAxgLDgAEIAWDcgc1G7IEyB6SJAFID5YA3nAHC6h4+H7s27nP1kTyOoQkGuJWtNGIJKYznRI3VEL7IaHq985ZUuKryZKcAtJsi5eULwUybm9KzajBBhywZ5ZwoJNuwDX5C/xBjvz5DbsoNsvG1NGQiqp0NMLZ7JlnW+5MaM3HwcHheUQeiVokekHkn/FRdefvJaTp2PczN+I1Sc3k9VuX51Tb0Tqqf1deVXGdJsDOhz0/EffMOPOzHNH06pYkDDjs+P8fb/z/8n9Iq8ITzWywkP6PBMMN9L/O7vY2FNoTAkp5PpD6g1nV9WmyQnM5uPpAMHR2fe06jbfvzPriekVTQxC6lpKr43oDtRZfCATl5OVAUKykqwm9o8R/kg37cxa6eZikS7cjK4aIwoyh6jOFplhFrz2b833G3Jii9AjDUiAZ9AxZtxdEYV6imvRF0+0Nej3wu6nPZrTLh81AVcV3kmMVdQj6Qbe9qetzbuDZ7vXOlRrqooFSxCv6SfrDICA6rnHZXQPVcUHJYGcoqa3jVH7ATrjWBNYYkEqF3RFpVIl0q2JvMOJd7/TyjXHw2NyAuJpNaEbz8RTEVtCbSH7JrwQQOqwGl7sTUOtdBZIY2DKqKlvOmPvUxJaURAZZcviTT0SKHCXqzwc=" ) format( "woff2" )', {} );
+  f.load()[ 'catch' ]( function() {} );
+  return f.status == 'loading' || f.status == 'loaded';
+})( window );
+
+// Public API function -
+var loadFont = function( fontName, woffUrl, woff2Url, onlyLoadFontOnSecondPageload ){
+
+  // Many unsupported browsers should stop here
+  var nua  = navigator.userAgent,
+      nope = !window.addEventListener || ( nua.match( /(Android (2|3|4.0|4.1|4.2|4.3))|(Opera (Mini|Mobi))/ ) && !nua.match( /Chrome/ ) );
+
+  if ( nope ) return;
+
+  // Set up LocalStorage
+  var loSto = {};
+
+  // Set up a proxy variable to help with LocalStorage
+  try { loSto = localStorage || {}; }
+  catch( ex ) {}
+
+  var loStoPrefix   = 'x-font-' + fontName,
+      loStoUrlKey   = loStoPrefix + 'url',
+      loStoCssKey   = loStoPrefix + 'css',
+      storedFontUrl = loSto[ loStoUrlKey ],
+      storedFontCss = loSto[ loStoCssKey ],
+      styleElement  = document.createElement( 'style' );
+
+  // Make <style> element & apply base64 encoded font data
+  styleElement.rel  = 'stylesheet';
+  document.head.appendChild( styleElement );
+
+  // CSS in LocalStorage & loaded from one of the current URLs
+  if ( storedFontCss && ( storedFontUrl === woffUrl || storedFontUrl === woff2Url ) ) {
+
+    styleElement.textContent = storedFontCss;
+
+  // Data not present or loaded from an obsolete URL
+  } else {
+
+    // Check for WOFF2 support
+    var cssUrl  = ( woff2Url && supportsWoff2 ) ? woff2Url : woffUrl,
+        request = new XMLHttpRequest();
+
+    // Fetch font data from the server
+    request.open( 'GET', cssUrl );
+    request.onload = function() {
+      if ( request.status >= 200 && request.status < 400 ) {
+
+        // Update LocalStorage with fresh data & apply
+        loSto[ loStoUrlKey ] = cssUrl;
+        loSto[ loStoCssKey ] = request.responseText;
+        if ( !onlyLoadFontOnSecondPageload ) styleElement.textContent = request.responseText;
+      }
+    };
+    request.send();
+  }
+};
+
+// Public API
+module.exports = loadFont;