ratchet_design 0.1.5 → 0.1.6

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/ajax.js

@@ -0,0 +1,122 @@
+/**
+ * Ajax 0.0.1
+ * Ajax module in Vanilla JS
+ * @author Fernando Daciuk (@fdaciuk) & Kyle Foster (@hkfoster)
+ * @source https://github.com/fdaciuk/ajax
+ * @license MIT
+ **/
+
+// Public API function
+var ajax = function( options ) {
+  var methods = [ 'get', 'post', 'put', 'delete' ];
+  options = options || {};
+  options.baseUrl = options.baseUrl || '';
+  if ( options.method && options.url ) {
+    return xhrConnection(
+      options.method,
+      options.baseUrl + options.url,
+      maybeData( options.data ),
+      options
+    );
+  }
+  return methods.reduce( function( acc, method ) {
+    acc[ method ] = function( url, data ) {
+      return xhrConnection(
+        method,
+        options.baseUrl + url,
+        maybeData( data ),
+        options
+      );
+    };
+    return acc;
+  }, {});
+
+  function maybeData( data ) {
+    return data || null;
+  }
+
+  function xhrConnection( type, url, data, options ) {
+    var returnMethods  = [ 'then', 'catch', 'always' ];
+    var promiseMethods = returnMethods.reduce( function( promise, method ) {
+      promise[ method ] = function( callback ) {
+        promise[ method ] = callback;
+        return promise;
+      };
+      return promise;
+    }, {});
+    var xhr = new XMLHttpRequest();
+    xhr.open( type, url, true );
+    xhr.withCredentials = options.hasOwnProperty( 'withCredentials' );
+    setHeaders( xhr, options.headers );
+    xhr.addEventListener( 'readystatechange', ready( promiseMethods, xhr ), false );
+    xhr.send( objectToQueryString( data ) );
+    promiseMethods.abort = function() {
+      return xhr.abort();
+    };
+    return promiseMethods;
+  }
+
+  function setHeaders( xhr, headers ) {
+    headers = headers || {};
+    if ( !hasContentType( headers ) ) {
+      headers[ 'Content-Type' ] = 'application/x-www-form-urlencoded';
+    }
+    Object.keys( headers ).forEach( function( name ) {
+      ( headers[ name ] && xhr.setRequestHeader( name, headers[ name ] ) );
+    });
+  }
+
+  function hasContentType( headers ) {
+    return Object.keys( headers ).some( function( name ) {
+      return name.toLowerCase() === 'content-type';
+    });
+  }
+
+  function ready( promiseMethods, xhr ) {
+    return function handleReady() {
+      if ( xhr.readyState === xhr.DONE ) {
+        xhr.removeEventListener( 'readystatechange', handleReady, false );
+        promiseMethods.always.apply( promiseMethods, parseResponse( xhr ) );
+
+        if ( xhr.status >= 200 && xhr.status < 300 ) {
+          promiseMethods.then.apply( promiseMethods, parseResponse( xhr ) );
+        } else {
+          promiseMethods.catch.apply( promiseMethods, parseResponse( xhr ) );
+        }
+      }
+    };
+  }
+
+  function parseResponse( xhr ) {
+    var result;
+    try {
+      result = JSON.parse( xhr.responseText );
+    } catch ( e ) {
+      result = xhr.responseText;
+    }
+    return [ result, xhr ];
+  }
+
+  function objectToQueryString( data ) {
+    return isObject( data ) ? getQueryString( data ) : data;
+  }
+
+  function isObject( data ) {
+    return Object.prototype.toString.call( data ) === '[ object Object ]';
+  }
+
+  function getQueryString( object ) {
+    return Object.keys( object ).reduce( function( acc, item ) {
+      var prefix = !acc ? '' : acc + '&';
+      return prefix + encode( item ) + '=' + encode( object[ item ] );
+    }, '' );
+  }
+
+  function encode( value ) {
+    return encodeURIComponent( value );
+  }
+
+};
+
+// Public API
+module.exports = ajax;

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

@@ -0,0 +1,40 @@
+/**
+ * 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, debug ) {
+
+  // Scoped variables
+  var formData  = new FormData(),
+      allFields = parent.querySelectorAll( 'input:not([type=submit])' );
+
+  // Loop over fields
+  for ( var i = 0; i < allFields.length; i++ ) {
+
+    // Cache current field
+    var field = allFields[ i ];
+
+    // If a name attribute is present
+    if ( field.name ) {
+
+      // Debug mode logging
+      if ( debug ) console.log( 'Name: ' + field.name + '\n' + 'Value: ' + field.value );
+
+      // Append current field’s name/value to new formData object
+      formData.append( field.name, field.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/matches.js

@@ -0,0 +1,15 @@
+/**
+ * Matches 0.0.1
+ * Matches selector function
+ * @author Kyle Foster (@hkfoster)
+ * @reference https://developer.mozilla.org/en-US/docs/Web/API/Element/matches
+ * @license MIT
+ **/
+
+// Public API function
+var matches = function ( el, selector ) {
+  return ( el.matches || el.matchesSelector || el.msMatchesSelector || el.mozMatchesSelector || el.webkitMatchesSelector || el.oMatchesSelector ).call( el, selector );
+};
+
+// Public API
+module.exports = matches;

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

@@ -0,0 +1,74 @@
+/**
+ * ScrollTo 0.0.1
+ * Scroll to element function
+ * @author James Doyle (@james2doyle) & Kyle Foster (@hkfoster)
+ * @source https://goo.gl/CeY8fY
+ * @license MIT
+ **/
+
+// Public API function
+var scrollTo = function( to, callback, duration ) {
+
+  // Scoped variables
+  var start     = position(),
+      change    = to - start,
+      currTime  = 0,
+      increment = 20;
+      duration  = ( typeof( duration ) === 'undefined' ) ? 500 : duration;
+
+  // Kick off scroll animation
+  animateScroll();
+
+  // Easing function -  http://goo.gl/5HLl8
+  function easeInOutQuad( t, b, c, d ) {
+    t /= d / 2;
+    if ( t < 1 ) {
+      return c / 2 * t * t + b;
+    }
+    t--;
+    return -c / 2 * ( t * ( t - 2 ) - 1 ) + b;
+  }
+
+  // Get current scroll position
+  function position() {
+    return document.documentElement.scrollTop ||
+           document.body.parentNode.scrollTop ||
+           document.body.scrollTop;
+  }
+
+  // Move scroll position
+  function move( amount ) {
+    document.documentElement.scrollTop = amount;
+    document.body.parentNode.scrollTop = amount;
+    document.body.scrollTop = amount;
+  }
+
+  // Scroll animation function
+  function animateScroll() {
+
+    // Increment the time
+    currTime += increment;
+
+    // Find the value with the quadratic in-out easing function
+    var val = easeInOutQuad( currTime, start, change, duration );
+
+    // Move the document.body
+    move( val );
+
+    // Do the animation unless its over
+    if ( currTime < duration ) {
+      requestAnimationFrame( animateScroll );
+    }
+
+    // The animation is done so let’s callback
+    else {
+      if ( callback && typeof( callback ) === 'function' ) {
+        callback();
+      }
+    }
+  }
+
+};
+
+// Public API
+module.exports = scrollTo;

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

@@ -0,0 +1,25 @@
+/**
+ * Throttle 0.0.1
+ * Event throttle function
+ * @author Kyle Foster (@hkfoster)
+ * @reference http://www.html5rocks.com/en/tutorials/speed/animations/
+ * @license MIT
+ **/
+
+// Public API function
+var throttle = function ( type, name, obj ) {
+  obj = obj || window;
+  var running = false;
+  var func = function () {
+    if ( running ) { return; }
+    running = true;
+    requestAnimationFrame( function () {
+      obj.dispatchEvent( new CustomEvent( name ) );
+      running = false;
+    });
+  };
+  obj.addEventListener( type, func );
+};
+
+// Public API
+module.exports = throttle;

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

@@ -0,0 +1,45 @@
+/**
+ * Timeout 0.0.1
+ * Just like setTimeout & clearTimeout, but with requestAnimationFrame()
+ * @author Joe Lambert (@joelambert) & Kyle Foster (@hkfoster)
+ * @source https://gist.github.com/joelambert/1002116#file-requesttimeout-js
+ * @license MIT
+ **/
+
+// Public API object
+var timeout = {
+
+  // Set timeout function
+  set : function( fn, delay, args ) {
+
+    var start  = Date.now(),
+        handle = {};
+
+    function loop() {
+
+      var current = Date.now(),
+          delta   = current - start;
+
+      if ( delta >= delay ) {
+        if ( args !== undefined ) {
+          fn.call( fn, args );
+        } else {
+          fn.call( fn );
+        }
+      } else {
+        handle.value = requestAnimationFrame( loop );
+      }
+    }
+
+    handle.value = requestAnimationFrame( loop );
+    return handle;
+  },
+
+  // Clear timeout function
+  clear : function( handle ) {
+    window.cancelAnimationFrame( handle.value );
+  }
+};
+
+// Public API
+module.exports = timeout;