/*! Shoestring - v2.0.1 - 2017-05-24
* http://github.com/filamentgroup/shoestring/
* Copyright (c) 2017 Scott Jehl, Filament Group, Inc; Licensed MIT & GPLv2 */
(function( factory ) {
if( typeof define === 'function' && define.amd ) {
// AMD. Register as an anonymous module.
define( [ 'shoestring' ], factory );
} else if (typeof module === 'object' && module.exports) {
// Node/CommonJS
module.exports = factory();
} else {
// Browser globals
factory();
}
}(function () {
var win = typeof window !== "undefined" ? window : this;
var doc = win.document;
/**
* The shoestring object constructor.
*
* @param {string,object} prim The selector to find or element to wrap.
* @param {object} sec The context in which to match the `prim` selector.
* @returns shoestring
* @this window
*/
function shoestring( prim, sec ){
var pType = typeof( prim ),
ret = [],
sel;
// return an empty shoestring object
if( !prim ){
return new Shoestring( ret );
}
// ready calls
if( prim.call ){
return shoestring.ready( prim );
}
// handle re-wrapping shoestring objects
if( prim.constructor === Shoestring && !sec ){
return prim;
}
// if string starting with <, make html
if( pType === "string" && prim.indexOf( "<" ) === 0 ){
var dfrag = doc.createElement( "div" );
dfrag.innerHTML = prim;
// TODO depends on children (circular)
return shoestring( dfrag ).children().each(function(){
dfrag.removeChild( this );
});
}
// if string, it's a selector, use qsa
if( pType === "string" ){
if( sec ){
return shoestring( sec ).find( prim );
}
try {
sel = doc.querySelectorAll( prim );
} catch( e ) {
shoestring.error( 'queryselector', prim );
}
return new Shoestring( sel, prim );
}
// array like objects or node lists
if( Object.prototype.toString.call( pType ) === '[object Array]' ||
(win.NodeList && prim instanceof win.NodeList) ){
return new Shoestring( prim, prim );
}
// if it's an array, use all the elements
if( prim.constructor === Array ){
return new Shoestring( prim, prim );
}
// otherwise assume it's an object the we want at an index
return new Shoestring( [prim], prim );
}
var Shoestring = function( ret, prim ) {
this.length = 0;
this.selector = prim;
shoestring.merge(this, ret);
};
// TODO only required for tests
Shoestring.prototype.reverse = [].reverse;
// For adding element set methods
shoestring.fn = Shoestring.prototype;
shoestring.Shoestring = Shoestring;
// For extending objects
// TODO move to separate module when we use prototypes
shoestring.extend = function( first, second ){
for( var i in second ){
if( second.hasOwnProperty( i ) ){
first[ i ] = second[ i ];
}
}
return first;
};
// taken directly from jQuery
shoestring.merge = function( first, second ) {
var len, j, i;
len = +second.length,
j = 0,
i = first.length;
for ( ; j < len; j++ ) {
first[ i++ ] = second[ j ];
}
first.length = i;
return first;
};
// expose
win.shoestring = shoestring;
shoestring.enUS = {
errors: {
"prefix": "Shoestring does not support",
"ajax-url-query": "data with urls that have existing query params",
"children-selector" : "passing selectors into .child, try .children().filter( selector )",
"click": "the click method. Try using .on( 'click', function(){}) or .trigger( 'click' ) instead.",
"css-get" : "getting computed attributes from the DOM.",
"data-attr-alias": "the data method aliased to `data-` DOM attributes.",
"each-length": "objects without a length passed into each",
"has-class" : "the hasClass method. Try using .is( '.klassname' ) instead.",
"html-function" : "passing a function into .html. Try generating the html you're passing in an outside function",
"index-shoestring-object": "an index call with a shoestring object argument. Use .get(0) on the argument instead.",
"live-delegate" : "the .live or .delegate methods. Use .bind or .on instead.",
"map": "the map method. Try using .each to make a new object.",
"next-selector" : "passing selectors into .next, try .next().filter( selector )",
"off-delegate" : ".off( events, selector, handler ) or .off( events, selector ). Use .off( eventName, callback ) instead.",
"next-until" : "the .nextUntil method. Use .next in a loop until you reach the selector, don't include the selector",
"on-delegate" : "the .on method with three or more arguments. Using .on( eventName, callback ) instead.",
"outer-width": "the outerWidth method. Try combining .width() with .css for padding-left, padding-right, and the border of the left and right side.",
"prev-selector" : "passing selectors into .prev, try .prev().filter( selector )",
"prevall-selector" : "passing selectors into .prevAll, try .prevAll().filter( selector )",
"queryselector": "all CSS selectors on querySelector (varies per browser support). Specifically, this failed: ",
"siblings-selector": "passing selector into siblings not supported, try .siblings().find( ... )",
"show-hide": "the show or hide methods. Use display: block (or whatever you'd like it to be) or none instead",
"text-setter": "setting text via the .text method.",
"toggle-class" : "the toggleClass method. Try using addClass or removeClass instead.",
"trim": "the trim method. Use String.prototype.trim."
}
};
shoestring.error = function( id, str ) {
var errors = shoestring.enUS.errors;
throw new Error( errors.prefix + " " + errors[id] + ( str ? " " + str : "" ) );
};
/**
* Make an HTTP request to a url.
*
* **NOTE** the following options are supported:
*
* - *method* - The HTTP method used with the request. Default: `GET`.
* - *data* - Raw object with keys and values to pass with request as query params. Default `null`.
* - *headers* - Set of request headers to add. Default `{}`.
* - *async* - Whether the opened request is asynchronouse. Default `true`.
* - *success* - Callback for successful request and response. Passed the response data.
* - *error* - Callback for failed request and response.
* - *cancel* - Callback for cancelled request and response.
*
* @param {string} url The url to request.
* @param {object} options The options object, see Notes.
* @return shoestring
* @this shoestring
*/
shoestring.ajax = function( url, options ) {
var params = "", req = new XMLHttpRequest(), settings, key;
settings = shoestring.extend( {}, shoestring.ajax.settings );
if( options ){
shoestring.extend( settings, options );
}
if( !url ){
url = settings.url;
}
if( !req || !url ){
return;
}
// create parameter string from data object
if( settings.data ){
for( key in settings.data ){
if( settings.data.hasOwnProperty( key ) ){
if( params !== "" ){
params += "&";
}
params += encodeURIComponent( key ) + "=" +
encodeURIComponent( settings.data[key] );
}
}
}
// append params to url for GET requests
if( settings.method === "GET" && params ){
if( url.indexOf("?") >= 0 ){
shoestring.error( 'ajax-url-query' );
}
url += "?" + params;
}
req.open( settings.method, url, settings.async );
if( req.setRequestHeader ){
req.setRequestHeader( "X-Requested-With", "XMLHttpRequest" );
// Set 'Content-type' header for POST requests
if( settings.method === "POST" && params ){
req.setRequestHeader( "Content-type", "application/x-www-form-urlencoded" );
}
for( key in settings.headers ){
if( settings.headers.hasOwnProperty( key ) ){
req.setRequestHeader(key, settings.headers[ key ]);
}
}
}
req.onreadystatechange = function () {
if( req.readyState === 4 ){
// Trim the whitespace so shoestring('
') works
var res = (req.responseText || '').replace(/^\s+|\s+$/g, '');
if( req.status.toString().indexOf( "0" ) === 0 ){
return settings.cancel( res, req.status, req );
}
else if ( req.status.toString().match( /^(4|5)/ ) && RegExp.$1 ){
return settings.error( res, req.status, req );
}
else if (settings.success) {
return settings.success( res, req.status, req );
}
}
};
if( req.readyState === 4 ){
return req;
}
// Send request
if( settings.method === "POST" && params ){
req.send( params );
} else {
req.send();
}
return req;
};
shoestring.ajax.settings = {
success: function(){},
error: function(){},
cancel: function(){},
method: "GET",
async: true,
data: null,
headers: {}
};
/**
* Helper function wrapping a call to [ajax](ajax.js.html) using the `GET` method.
*
* @param {string} url The url to GET from.
* @param {function} callback Callback to invoke on success.
* @return shoestring
* @this shoestring
*/
shoestring.get = function( url, callback ){
return shoestring.ajax( url, { success: callback } );
};
/**
* Load the HTML response from `url` into the current set of elements.
*
* @param {string} url The url to GET from.
* @param {function} callback Callback to invoke after HTML is inserted.
* @return shoestring
* @this shoestring
*/
shoestring.fn.load = function( url, callback ){
var self = this,
args = arguments,
intCB = function( data ){
self.each(function(){
shoestring( this ).html( data );
});
if( callback ){
callback.apply( self, args );
}
};
shoestring.ajax( url, { success: intCB } );
return this;
};
/**
* Helper function wrapping a call to [ajax](ajax.js.html) using the `POST` method.
*
* @param {string} url The url to POST to.
* @param {object} data The data to send.
* @param {function} callback Callback to invoke on success.
* @return shoestring
* @this shoestring
*/
shoestring.post = function( url, data, callback ){
return shoestring.ajax( url, { data: data, method: "POST", success: callback } );
};
/**
* Iterates over `shoestring` collections.
*
* @param {function} callback The callback to be invoked on each element and index
* @return shoestring
* @this shoestring
*/
shoestring.fn.each = function( callback ){
return shoestring.each( this, callback );
};
shoestring.each = function( collection, callback ) {
var val;
if( !( "length" in collection ) ) {
shoestring.error( 'each-length' );
}
for( var i = 0, il = collection.length; i < il; i++ ){
val = callback.call( collection[i], i, collection[i] );
if( val === false ){
break;
}
}
return collection;
};
/**
* Check for array membership.
*
* @param {object} needle The thing to find.
* @param {object} haystack The thing to find the needle in.
* @return {boolean}
* @this window
*/
shoestring.inArray = function( needle, haystack ){
var isin = -1;
for( var i = 0, il = haystack.length; i < il; i++ ){
if( haystack.hasOwnProperty( i ) && haystack[ i ] === needle ){
isin = i;
}
}
return isin;
};
/**
* Bind callbacks to be run when the DOM is "ready".
*
* @param {function} fn The callback to be run
* @return shoestring
* @this shoestring
*/
shoestring.ready = function( fn ){
if( ready && fn ){
fn.call( doc );
}
else if( fn ){
readyQueue.push( fn );
}
else {
runReady();
}
return [doc];
};
// TODO necessary?
shoestring.fn.ready = function( fn ){
shoestring.ready( fn );
return this;
};
// Empty and exec the ready queue
var ready = false,
readyQueue = [],
runReady = function(){
if( !ready ){
while( readyQueue.length ){
readyQueue.shift().call( doc );
}
ready = true;
}
};
// If DOM is already ready at exec time, depends on the browser.
// From: https://github.com/mobify/mobifyjs/blob/526841be5509e28fc949038021799e4223479f8d/src/capture.js#L128
if (doc.attachEvent ? doc.readyState === "complete" : doc.readyState !== "loading") {
runReady();
} else {
doc.addEventListener( "DOMContentLoaded", runReady, false );
doc.addEventListener( "readystatechange", runReady, false );
win.addEventListener( "load", runReady, false );
}
/**
* Checks the current set of elements against the selector, if one matches return `true`.
*
* @param {string} selector The selector to check.
* @return {boolean}
* @this {shoestring}
*/
shoestring.fn.is = function( selector ){
var ret = false, self = this, parents, check;
// assume a dom element
if( typeof selector !== "string" ){
// array-like, ie shoestring objects or element arrays
if( selector.length && selector[0] ){
check = selector;
} else {
check = [selector];
}
return _checkElements(this, check);
}
parents = this.parent();
if( !parents.length ){
parents = shoestring( doc );
}
parents.each(function( i, e ) {
var children;
try {
children = e.querySelectorAll( selector );
} catch( e ) {
shoestring.error( 'queryselector', selector );
}
ret = _checkElements( self, children );
});
return ret;
};
function _checkElements(needles, haystack){
var ret = false;
needles.each(function() {
var j = 0;
while( j < haystack.length ){
if( this === haystack[j] ){
ret = true;
}
j++;
}
});
return ret;
}
/**
* Get data attached to the first element or set data values on all elements in the current set.
*
* @param {string} name The data attribute name.
* @param {any} value The value assigned to the data attribute.
* @return {any|shoestring}
* @this shoestring
*/
shoestring.fn.data = function( name, value ){
if( name !== undefined ){
if( value !== undefined ){
return this.each(function(){
if( !this.shoestringData ){
this.shoestringData = {};
}
this.shoestringData[ name ] = value;
});
}
else {
if( this[ 0 ] ) {
if( this[ 0 ].shoestringData ) {
return this[ 0 ].shoestringData[ name ];
}
if( shoestring( this[ 0 ] ).is( "[data-" + name + "]" ) ){
shoestring.error( 'data-attr-alias' );
}
}
}
}
else {
return this[ 0 ] ? this[ 0 ].shoestringData || {} : undefined;
}
};
/**
* Remove data associated with `name` or all the data, for each element in the current set.
*
* @param {string} name The data attribute name.
* @return shoestring
* @this shoestring
*/
shoestring.fn.removeData = function( name ){
return this.each(function(){
if( name !== undefined && this.shoestringData ){
this.shoestringData[ name ] = undefined;
delete this.shoestringData[ name ];
} else {
this[ 0 ].shoestringData = {};
}
});
};
/**
* An alias for the `shoestring` constructor.
*/
win.$ = shoestring;
/**
* Add a class to each DOM element in the set of elements.
*
* @param {string} className The name of the class to be added.
* @return shoestring
* @this shoestring
*/
shoestring.fn.addClass = function( className ){
var classes = className.replace(/^\s+|\s+$/g, '').split( " " );
return this.each(function(){
for( var i = 0, il = classes.length; i < il; i++ ){
if( this.className !== undefined &&
(this.className === "" ||
!this.className.match( new RegExp( "(^|\\s)" + classes[ i ] + "($|\\s)"))) ){
this.className += " " + classes[ i ];
}
}
});
};
/**
* Add elements matching the selector to the current set.
*
* @param {string} selector The selector for the elements to add from the DOM
* @return shoestring
* @this shoestring
*/
shoestring.fn.add = function( selector ){
var ret = [];
this.each(function(){
ret.push( this );
});
shoestring( selector ).each(function(){
ret.push( this );
});
return shoestring( ret );
};
/**
* Insert an element or HTML string after each element in the current set.
*
* @param {string|HTMLElement} fragment The HTML or HTMLElement to insert.
* @return shoestring
* @this shoestring
*/
shoestring.fn.after = function( fragment ){
if( typeof( fragment ) === "string" || fragment.nodeType !== undefined ){
fragment = shoestring( fragment );
}
if( fragment.length > 1 ){
fragment = fragment.reverse();
}
return this.each(function( i ){
for( var j = 0, jl = fragment.length; j < jl; j++ ){
var insertEl = i > 0 ? fragment[ j ].cloneNode( true ) : fragment[ j ];
this.parentNode.insertBefore( insertEl, this.nextSibling );
}
});
};
/**
* Insert an element or HTML string as the last child of each element in the set.
*
* @param {string|HTMLElement} fragment The HTML or HTMLElement to insert.
* @return shoestring
* @this shoestring
*/
shoestring.fn.append = function( fragment ){
if( typeof( fragment ) === "string" || fragment.nodeType !== undefined ){
fragment = shoestring( fragment );
}
return this.each(function( i ){
for( var j = 0, jl = fragment.length; j < jl; j++ ){
this.appendChild( i > 0 ? fragment[ j ].cloneNode( true ) : fragment[ j ] );
}
});
};
/**
* Insert the current set as the last child of the elements matching the selector.
*
* @param {string} selector The selector after which to append the current set.
* @return shoestring
* @this shoestring
*/
shoestring.fn.appendTo = function( selector ){
return this.each(function(){
shoestring( selector ).append( this );
});
};
/**
* Get the value of the first element of the set or set the value of all the elements in the set.
*
* @param {string} name The attribute name.
* @param {string} value The new value for the attribute.
* @return {shoestring|string|undefined}
* @this {shoestring}
*/
shoestring.fn.attr = function( name, value ){
var nameStr = typeof( name ) === "string";
if( value !== undefined || !nameStr ){
return this.each(function(){
if( nameStr ){
this.setAttribute( name, value );
} else {
for( var i in name ){
if( name.hasOwnProperty( i ) ){
this.setAttribute( i, name[ i ] );
}
}
}
});
} else {
return this[ 0 ] ? this[ 0 ].getAttribute( name ) : undefined;
}
};
/**
* Insert an element or HTML string before each element in the current set.
*
* @param {string|HTMLElement} fragment The HTML or HTMLElement to insert.
* @return shoestring
* @this shoestring
*/
shoestring.fn.before = function( fragment ){
if( typeof( fragment ) === "string" || fragment.nodeType !== undefined ){
fragment = shoestring( fragment );
}
return this.each(function( i ){
for( var j = 0, jl = fragment.length; j < jl; j++ ){
this.parentNode.insertBefore( i > 0 ? fragment[ j ].cloneNode( true ) : fragment[ j ], this );
}
});
};
/**
* Get the children of the current collection.
* @return shoestring
* @this shoestring
*/
shoestring.fn.children = function(){
if( arguments.length > 0 ){
shoestring.error( 'children-selector' );
}
var ret = [],
childs,
j;
this.each(function(){
childs = this.children;
j = -1;
while( j++ < childs.length-1 ){
if( shoestring.inArray( childs[ j ], ret ) === -1 ){
ret.push( childs[ j ] );
}
}
});
return shoestring(ret);
};
/**
* Clone and return the current set of nodes into a new `shoestring` object.
*
* @return shoestring
* @this shoestring
*/
shoestring.fn.clone = function() {
var ret = [];
this.each(function() {
ret.push( this.cloneNode( true ) );
});
return shoestring( ret );
};
/**
* Find an element matching the selector in the set of the current element and its parents.
*
* @param {string} selector The selector used to identify the target element.
* @return shoestring
* @this shoestring
*/
shoestring.fn.closest = function( selector ){
var ret = [];
if( !selector ){
return shoestring( ret );
}
this.each(function(){
var element, $self = shoestring( element = this );
if( $self.is(selector) ){
ret.push( this );
return;
}
while( element.parentElement ) {
if( shoestring(element.parentElement).is(selector) ){
ret.push( element.parentElement );
break;
}
element = element.parentElement;
}
});
return shoestring( ret );
};
shoestring.cssExceptions = {
'float': [ 'cssFloat' ]
};
(function() {
var cssExceptions = shoestring.cssExceptions;
// marginRight instead of margin-right
function convertPropertyName( str ) {
return str.replace( /\-([A-Za-z])/g, function ( match, character ) {
return character.toUpperCase();
});
}
function _getStyle( element, property ) {
return win.getComputedStyle( element, null ).getPropertyValue( property );
}
var vendorPrefixes = [ '', '-webkit-', '-ms-', '-moz-', '-o-', '-khtml-' ];
/**
* Private function for getting the computed style of an element.
*
* **NOTE** Please use the [css](../css.js.html) method instead.
*
* @method _getStyle
* @param {HTMLElement} element The element we want the style property for.
* @param {string} property The css property we want the style for.
*/
shoestring._getStyle = function( element, property ) {
var convert, value, j, k;
if( cssExceptions[ property ] ) {
for( j = 0, k = cssExceptions[ property ].length; j < k; j++ ) {
value = _getStyle( element, cssExceptions[ property ][ j ] );
if( value ) {
return value;
}
}
}
for( j = 0, k = vendorPrefixes.length; j < k; j++ ) {
convert = convertPropertyName( vendorPrefixes[ j ] + property );
// VendorprefixKeyName || key-name
value = _getStyle( element, convert );
if( convert !== property ) {
value = value || _getStyle( element, property );
}
if( vendorPrefixes[ j ] ) {
// -vendorprefix-key-name
value = value || _getStyle( element, vendorPrefixes[ j ] + property );
}
if( value ) {
return value;
}
}
return undefined;
};
})();
(function() {
var cssExceptions = shoestring.cssExceptions;
// marginRight instead of margin-right
function convertPropertyName( str ) {
return str.replace( /\-([A-Za-z])/g, function ( match, character ) {
return character.toUpperCase();
});
}
/**
* Private function for setting the style of an element.
*
* **NOTE** Please use the [css](../css.js.html) method instead.
*
* @method _setStyle
* @param {HTMLElement} element The element we want to style.
* @param {string} property The property being used to style the element.
* @param {string} value The css value for the style property.
*/
shoestring._setStyle = function( element, property, value ) {
var convertedProperty = convertPropertyName(property);
element.style[ property ] = value;
if( convertedProperty !== property ) {
element.style[ convertedProperty ] = value;
}
if( cssExceptions[ property ] ) {
for( var j = 0, k = cssExceptions[ property ].length; j -1 ){
ret.push( this );
}
}
});
return shoestring( ret );
};
/**
* Find descendant elements of the current collection.
*
* @param {string} selector The selector used to find the children
* @return shoestring
* @this shoestring
*/
shoestring.fn.find = function( selector ){
var ret = [],
finds;
this.each(function(){
try {
finds = this.querySelectorAll( selector );
} catch( e ) {
shoestring.error( 'queryselector', selector );
}
for( var i = 0, il = finds.length; i < il; i++ ){
ret = ret.concat( finds[i] );
}
});
return shoestring( ret );
};
/**
* Returns the first element of the set wrapped in a new `shoestring` object.
*
* @return shoestring
* @this shoestring
*/
shoestring.fn.first = function(){
return this.eq( 0 );
};
/**
* Returns the raw DOM node at the passed index.
*
* @param {integer} index The index of the element to wrap and return.
* @return {HTMLElement|undefined|array}
* @this shoestring
*/
shoestring.fn.get = function( index ){
// return an array of elements if index is undefined
if( index === undefined ){
var elements = [];
for( var i = 0; i < this.length; i++ ){
elements.push( this[ i ] );
}
return elements;
} else {
return this[ index ];
}
};
/**
* Private function for setting/getting the offset property for height/width.
*
* **NOTE** Please use the [width](width.js.html) or [height](height.js.html) methods instead.
*
* @param {shoestring} set The set of elements.
* @param {string} name The string "height" or "width".
* @param {float|undefined} value The value to assign.
* @return shoestring
* @this window
*/
shoestring._dimension = function( set, name, value ){
var offsetName;
if( value === undefined ){
offsetName = name.replace(/^[a-z]/, function( letter ) {
return letter.toUpperCase();
});
return set[ 0 ][ "offset" + offsetName ];
} else {
// support integer values as pixels
value = typeof value === "string" ? value : value + "px";
return set.each(function(){
this.style[ name ] = value;
});
}
};
/**
* Gets the height value of the first element or sets the height for the whole set.
*
* @param {float|undefined} value The value to assign.
* @return shoestring
* @this shoestring
*/
shoestring.fn.height = function( value ){
return shoestring._dimension( this, "height", value );
};
var set = function( html ){
if( typeof html === "string" || typeof html === "number" ){
return this.each(function(){
this.innerHTML = "" + html;
});
} else {
var h = "";
if( typeof html.length !== "undefined" ){
for( var i = 0, l = html.length; i < l; i++ ){
h += html[i].outerHTML;
}
} else {
h = html.outerHTML;
}
return this.each(function(){
this.innerHTML = h;
});
}
};
/**
* Gets or sets the `innerHTML` from all the elements in the set.
*
* @param {string|undefined} html The html to assign
* @return {string|shoestring}
* @this shoestring
*/
shoestring.fn.html = function( html ){
if( !!html && typeof html === "function" ){
shoestring.error( 'html-function' );
}
if( typeof html !== "undefined" ){
return set.call( this, html );
} else { // get
var pile = "";
this.each(function(){
pile += this.innerHTML;
});
return pile;
}
};
(function() {
function _getIndex( set, test ) {
var i, result, element;
for( i = result = 0; i < set.length; i++ ) {
element = set.item ? set.item(i) : set[i];
if( test(element) ){
return result;
}
// ignore text nodes, etc
// NOTE may need to be more permissive
if( element.nodeType === 1 ){
result++;
}
}
return -1;
}
/**
* Find the index in the current set for the passed selector.
* Without a selector it returns the index of the first node within the array of its siblings.
*
* @param {string|undefined} selector The selector used to search for the index.
* @return {integer}
* @this {shoestring}
*/
shoestring.fn.index = function( selector ){
var self, children;
self = this;
// no arg? check the children, otherwise check each element that matches
if( selector === undefined ){
children = ( ( this[ 0 ] && this[0].parentNode ) || doc.documentElement).childNodes;
// check if the element matches the first of the set
return _getIndex(children, function( element ) {
return self[0] === element;
});
} else {
if( selector.constructor === shoestring.Shoestring ) {
shoestring.error( "index-shoestring-object" );
}
// check if the element matches the first selected node from the parent
return _getIndex(self, function( element ) {
return element === (shoestring( selector, element.parentNode )[ 0 ]);
});
}
};
})();
/**
* Insert the current set after the elements matching the selector.
*
* @param {string} selector The selector after which to insert the current set.
* @return shoestring
* @this shoestring
*/
shoestring.fn.insertAfter = function( selector ){
return this.each(function(){
shoestring( selector ).after( this );
});
};
/**
* Insert the current set before the elements matching the selector.
*
* @param {string} selector The selector before which to insert the current set.
* @return shoestring
* @this shoestring
*/
shoestring.fn.insertBefore = function( selector ){
return this.each(function(){
shoestring( selector ).before( this );
});
};
/**
* Returns the last element of the set wrapped in a new `shoestring` object.
*
* @return shoestring
* @this shoestring
*/
shoestring.fn.last = function(){
return this.eq( this.length - 1 );
};
/**
* Returns a `shoestring` object with the set of siblings of each element in the original set.
*
* @return shoestring
* @this shoestring
*/
shoestring.fn.next = function(){
if( arguments.length > 0 ){
shoestring.error( 'next-selector' );
}
var result = [];
// TODO need to implement map
this.each(function() {
var children, item, found;
// get the child nodes for this member of the set
children = shoestring( this.parentNode )[0].childNodes;
for( var i = 0; i < children.length; i++ ){
item = children.item( i );
// found the item we needed (found) which means current item value is
// the next node in the list, as long as it's viable grab it
// NOTE may need to be more permissive
if( found && item.nodeType === 1 ){
result.push( item );
break;
}
// find the current item and mark it as found
if( item === this ){
found = true;
}
}
});
return shoestring( result );
};
/**
* Removes elements from the current set.
*
* @param {string} selector The selector to use when removing the elements.
* @return shoestring
* @this shoestring
*/
shoestring.fn.not = function( selector ){
var ret = [];
this.each(function(){
var found = shoestring( selector, this.parentNode );
if( shoestring.inArray(this, found) === -1 ){
ret.push( this );
}
});
return shoestring( ret );
};
/**
* Returns an object with the `top` and `left` properties corresponging to the first elements offsets.
*
* @return object
* @this shoestring
*/
shoestring.fn.offset = function(){
return {
top: this[ 0 ].offsetTop,
left: this[ 0 ].offsetLeft
};
};
/**
* Returns the set of first parents for each element in the current set.
*
* @return shoestring
* @this shoestring
*/
shoestring.fn.parent = function(){
var ret = [],
parent;
this.each(function(){
// no parent node, assume top level
// jQuery parent: return the document object for or the parent node if it exists
parent = (this === doc.documentElement ? doc : this.parentNode);
// if there is a parent and it's not a document fragment
if( parent && parent.nodeType !== 11 ){
ret.push( parent );
}
});
return shoestring(ret);
};
/**
* Returns the set of all parents matching the selector if provided for each element in the current set.
*
* @param {string} selector The selector to check the parents with.
* @return shoestring
* @this shoestring
*/
shoestring.fn.parents = function( selector ){
var ret = [];
this.each(function(){
var curr = this, match;
while( curr.parentElement && !match ){
curr = curr.parentElement;
if( selector ){
if( curr === shoestring( selector )[0] ){
match = true;
if( shoestring.inArray( curr, ret ) === -1 ){
ret.push( curr );
}
}
} else {
if( shoestring.inArray( curr, ret ) === -1 ){
ret.push( curr );
}
}
}
});
return shoestring(ret);
};
/**
* Add an HTML string or element before the children of each element in the current set.
*
* @param {string|HTMLElement} fragment The HTML string or element to add.
* @return shoestring
* @this shoestring
*/
shoestring.fn.prepend = function( fragment ){
if( typeof( fragment ) === "string" || fragment.nodeType !== undefined ){
fragment = shoestring( fragment );
}
return this.each(function( i ){
for( var j = 0, jl = fragment.length; j < jl; j++ ){
var insertEl = i > 0 ? fragment[ j ].cloneNode( true ) : fragment[ j ];
if ( this.firstChild ){
this.insertBefore( insertEl, this.firstChild );
} else {
this.appendChild( insertEl );
}
}
});
};
/**
* Add each element of the current set before the children of the selected elements.
*
* @param {string} selector The selector for the elements to add the current set to..
* @return shoestring
* @this shoestring
*/
shoestring.fn.prependTo = function( selector ){
return this.each(function(){
shoestring( selector ).prepend( this );
});
};
/**
* Returns a `shoestring` object with the set of *one* siblingx before each element in the original set.
*
* @return shoestring
* @this shoestring
*/
shoestring.fn.prev = function(){
if( arguments.length > 0 ){
shoestring.error( 'prev-selector' );
}
var result = [];
// TODO need to implement map
this.each(function() {
var children, item, found;
// get the child nodes for this member of the set
children = shoestring( this.parentNode )[0].childNodes;
for( var i = children.length -1; i >= 0; i-- ){
item = children.item( i );
// found the item we needed (found) which means current item value is
// the next node in the list, as long as it's viable grab it
// NOTE may need to be more permissive
if( found && item.nodeType === 1 ){
result.push( item );
break;
}
// find the current item and mark it as found
if( item === this ){
found = true;
}
}
});
return shoestring( result );
};
/**
* Returns a `shoestring` object with the set of *all* siblings before each element in the original set.
*
* @return shoestring
* @this shoestring
*/
shoestring.fn.prevAll = function(){
if( arguments.length > 0 ){
shoestring.error( 'prevall-selector' );
}
var result = [];
this.each(function() {
var $previous = shoestring( this ).prev();
while( $previous.length ){
result.push( $previous[0] );
$previous = $previous.prev();
}
});
return shoestring( result );
};
// Property normalization, a subset taken from jQuery src
shoestring.propFix = {
"class": "className",
contenteditable: "contentEditable",
"for": "htmlFor",
readonly: "readOnly",
tabindex: "tabIndex"
};
/**
* Gets the property value from the first element or sets the property value on all elements of the currrent set.
*
* @param {string} name The property name.
* @param {any} value The property value.
* @return {any|shoestring}
* @this shoestring
*/
shoestring.fn.prop = function( name, value ){
if( !this[0] ){
return;
}
name = shoestring.propFix[ name ] || name;
if( value !== undefined ){
return this.each(function(){
this[ name ] = value;
});
} else {
return this[ 0 ][ name ];
}
};
/**
* Remove an attribute from each element in the current set.
*
* @param {string} name The name of the attribute.
* @return shoestring
* @this shoestring
*/
shoestring.fn.removeAttr = function( name ){
return this.each(function(){
this.removeAttribute( name );
});
};
/**
* Remove a class from each DOM element in the set of elements.
*
* @param {string} className The name of the class to be removed.
* @return shoestring
* @this shoestring
*/
shoestring.fn.removeClass = function( cname ){
var classes = cname.replace(/^\s+|\s+$/g, '').split( " " );
return this.each(function(){
var newClassName, regex;
for( var i = 0, il = classes.length; i < il; i++ ){
if( this.className !== undefined ){
regex = new RegExp( "(^|\\s)" + classes[ i ] + "($|\\s)", "gmi" );
newClassName = this.className.replace( regex, " " );
this.className = newClassName.replace(/^\s+|\s+$/g, '');
}
}
});
};
/**
* Remove the current set of elements from the DOM.
*
* @return shoestring
* @this shoestring
*/
shoestring.fn.remove = function(){
return this.each(function(){
if( this.parentNode ) {
this.parentNode.removeChild( this );
}
});
};
/**
* Remove a proprety from each element in the current set.
*
* @param {string} name The name of the property.
* @return shoestring
* @this shoestring
*/
shoestring.fn.removeProp = function( property ){
var name = shoestring.propFix[ property ] || property;
return this.each(function(){
this[ name ] = undefined;
delete this[ name ];
});
};
/**
* Replace each element in the current set with that argument HTML string or HTMLElement.
*
* @param {string|HTMLElement} fragment The value to assign.
* @return shoestring
* @this shoestring
*/
shoestring.fn.replaceWith = function( fragment ){
if( typeof( fragment ) === "string" ){
fragment = shoestring( fragment );
}
var ret = [];
if( fragment.length > 1 ){
fragment = fragment.reverse();
}
this.each(function( i ){
var clone = this.cloneNode( true ),
insertEl;
ret.push( clone );
// If there is no parentNode, this is pointless, drop it.
if( !this.parentNode ){ return; }
if( fragment.length === 1 ){
insertEl = i > 0 ? fragment[ 0 ].cloneNode( true ) : fragment[ 0 ];
this.parentNode.replaceChild( insertEl, this );
} else {
for( var j = 0, jl = fragment.length; j < jl; j++ ){
insertEl = i > 0 ? fragment[ j ].cloneNode( true ) : fragment[ j ];
this.parentNode.insertBefore( insertEl, this.nextSibling );
}
this.parentNode.removeChild( this );
}
});
return shoestring( ret );
};
shoestring.inputTypes = [
"text",
"hidden",
"password",
"color",
"date",
"datetime",
// "datetime\-local" matched by datetime
"email",
"month",
"number",
"range",
"search",
"tel",
"time",
"url",
"week"
];
shoestring.inputTypeTest = new RegExp( shoestring.inputTypes.join( "|" ) );
/**
* Serialize child input element values into an object.
*
* @return shoestring
* @this shoestring
*/
shoestring.fn.serialize = function(){
var data = {};
shoestring( "input, select", this ).each(function(){
var type = this.type, name = this.name, value = this.value;
if( shoestring.inputTypeTest.test( type ) ||
( type === "checkbox" || type === "radio" ) &&
this.checked ){
data[ name ] = value;
} else if( this.nodeName === "SELECT" ){
data[ name ] = this.options[ this.selectedIndex ].nodeValue;
}
});
return data;
};
/**
* Get all of the sibling elements for each element in the current set.
*
* @return shoestring
* @this shoestring
*/
shoestring.fn.siblings = function(){
if( arguments.length > 0 ) {
shoestring.error( 'siblings-selector' );
}
if( !this.length ) {
return shoestring( [] );
}
var sibs = [], el = this[ 0 ].parentNode.firstChild;
do {
if( el.nodeType === 1 && el !== this[ 0 ] ) {
sibs.push( el );
}
el = el.nextSibling;
} while( el );
return shoestring( sibs );
};
var getText = function( elem ){
var node,
ret = "",
i = 0,
nodeType = elem.nodeType;
if ( !nodeType ) {
// If no nodeType, this is expected to be an array
while ( (node = elem[i++]) ) {
// Do not traverse comment nodes
ret += getText( node );
}
} else if ( nodeType === 1 || nodeType === 9 || nodeType === 11 ) {
// Use textContent for elements
// innerText usage removed for consistency of new lines (jQuery #11153)
if ( typeof elem.textContent === "string" ) {
return elem.textContent;
} else {
// Traverse its children
for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {
ret += getText( elem );
}
}
} else if ( nodeType === 3 || nodeType === 4 ) {
return elem.nodeValue;
}
// Do not include comment or processing instruction nodes
return ret;
};
/**
* Recursively retrieve the text content of the each element in the current set.
*
* @return shoestring
* @this shoestring
*/
shoestring.fn.text = function() {
if( arguments.length > 0 ){
shoestring.error( 'text-setter' );
}
return getText( this );
};
/**
* Get the value of the first element or set the value of all elements in the current set.
*
* @param {string} value The value to set.
* @return shoestring
* @this shoestring
*/
shoestring.fn.val = function( value ){
var el;
if( value !== undefined ){
return this.each(function(){
if( this.tagName === "SELECT" ){
var optionSet, option,
options = this.options,
values = [],
i = options.length,
newIndex;
values[0] = value;
while ( i-- ) {
option = options[ i ];
if ( (option.selected = shoestring.inArray( option.value, values ) >= 0) ) {
optionSet = true;
newIndex = i;
}
}
// force browsers to behave consistently when non-matching value is set
if ( !optionSet ) {
this.selectedIndex = -1;
} else {
this.selectedIndex = newIndex;
}
} else {
this.value = value;
}
});
} else {
el = this[0];
if( el.tagName === "SELECT" ){
if( el.selectedIndex < 0 ){ return ""; }
return el.options[ el.selectedIndex ].value;
} else {
return el.value;
}
}
};
/**
* Gets the width value of the first element or sets the width for the whole set.
*
* @param {float|undefined} value The value to assign.
* @return shoestring
* @this shoestring
*/
shoestring.fn.width = function( value ){
return shoestring._dimension( this, "width", value );
};
/**
* Wraps the child elements in the provided HTML.
*
* @param {string} html The wrapping HTML.
* @return shoestring
* @this shoestring
*/
shoestring.fn.wrapInner = function( html ){
return this.each(function(){
var inH = this.innerHTML;
this.innerHTML = "";
shoestring( this ).append( shoestring( html ).html( inH ) );
});
};
function initEventCache( el, evt ) {
if ( !el.shoestringData ) {
el.shoestringData = {};
}
if ( !el.shoestringData.events ) {
el.shoestringData.events = {};
}
if ( !el.shoestringData.loop ) {
el.shoestringData.loop = {};
}
if ( !el.shoestringData.events[ evt ] ) {
el.shoestringData.events[ evt ] = [];
}
}
function addToEventCache( el, evt, eventInfo ) {
var obj = {};
obj.isCustomEvent = eventInfo.isCustomEvent;
obj.callback = eventInfo.callfunc;
obj.originalCallback = eventInfo.originalCallback;
obj.namespace = eventInfo.namespace;
el.shoestringData.events[ evt ].push( obj );
if( eventInfo.customEventLoop ) {
el.shoestringData.loop[ evt ] = eventInfo.customEventLoop;
}
}
/**
* Bind a callback to an event for the currrent set of elements.
*
* @param {string} evt The event(s) to watch for.
* @param {object,function} data Data to be included with each event or the callback.
* @param {function} originalCallback Callback to be invoked when data is define.d.
* @return shoestring
* @this shoestring
*/
shoestring.fn.bind = function( evt, data, originalCallback ){
if( arguments.length > 3 ){
shoestring.error( 'on-delegate' );
}
if( typeof data === "string" ){
shoestring.error( 'on-delegate' );
}
if( typeof data === "function" ){
originalCallback = data;
data = null;
}
var evts = evt.split( " " );
// NOTE the `triggeredElement` is purely for custom events from IE
function encasedCallback( e, namespace, triggeredElement ){
var result;
if( e._namespace && e._namespace !== namespace ) {
return;
}
e.data = data;
e.namespace = e._namespace;
var returnTrue = function(){
return true;
};
e.isDefaultPrevented = function(){
return false;
};
var originalPreventDefault = e.preventDefault;
var preventDefaultConstructor = function(){
if( originalPreventDefault ) {
return function(){
e.isDefaultPrevented = returnTrue;
originalPreventDefault.call(e);
};
} else {
return function(){
e.isDefaultPrevented = returnTrue;
e.returnValue = false;
};
}
};
// thanks https://github.com/jonathantneal/EventListener
e.target = triggeredElement || e.target || e.srcElement;
e.preventDefault = preventDefaultConstructor();
e.stopPropagation = e.stopPropagation || function () {
e.cancelBubble = true;
};
result = originalCallback.apply(this, [ e ].concat( e._args ) );
if( result === false ){
e.preventDefault();
e.stopPropagation();
}
return result;
}
return this.each(function(){
var domEventCallback,
customEventCallback,
customEventLoop,
oEl = this;
for( var i = 0, il = evts.length; i < il; i++ ){
var split = evts[ i ].split( "." ),
evt = split[ 0 ],
namespace = split.length > 0 ? split[ 1 ] : null;
domEventCallback = function( originalEvent ) {
if( oEl.ssEventTrigger ) {
originalEvent._namespace = oEl.ssEventTrigger._namespace;
originalEvent._args = oEl.ssEventTrigger._args;
oEl.ssEventTrigger = null;
}
return encasedCallback.call( oEl, originalEvent, namespace );
};
customEventCallback = null;
customEventLoop = null;
initEventCache( this, evt );
this.addEventListener( evt, domEventCallback, false );
addToEventCache( this, evt, {
callfunc: customEventCallback || domEventCallback,
isCustomEvent: !!customEventCallback,
customEventLoop: customEventLoop,
originalCallback: originalCallback,
namespace: namespace
});
}
});
};
shoestring.fn.on = shoestring.fn.bind;
shoestring.fn.live = function(){
shoestring.error( 'live-delegate' );
};
shoestring.fn.delegate = function(){
shoestring.error( 'live-delegate' );
};
/**
* Unbind a previous bound callback for an event.
*
* @param {string} event The event(s) the callback was bound to..
* @param {function} callback Callback to unbind.
* @return shoestring
* @this shoestring
*/
shoestring.fn.unbind = function( event, callback ){
if( arguments.length >= 3 || typeof callback === "string" ){
shoestring.error( 'off-delegate' );
}
var evts = event ? event.split( " " ) : [];
return this.each(function(){
if( !this.shoestringData || !this.shoestringData.events ) {
return;
}
if( !evts.length ) {
unbindAll.call( this );
} else {
var split, evt, namespace;
for( var i = 0, il = evts.length; i < il; i++ ){
split = evts[ i ].split( "." ),
evt = split[ 0 ],
namespace = split.length > 0 ? split[ 1 ] : null;
if( evt ) {
unbind.call( this, evt, namespace, callback );
} else {
unbindAll.call( this, namespace, callback );
}
}
}
});
};
function unbind( evt, namespace, callback ) {
var bound = this.shoestringData.events[ evt ];
if( !(bound && bound.length) ) {
return;
}
var matched = [], j, jl;
for( j = 0, jl = bound.length; j < jl; j++ ) {
if( !namespace || namespace === bound[ j ].namespace ) {
if( callback === undefined || callback === bound[ j ].originalCallback ) {
this.removeEventListener( evt, bound[ j ].callback, false );
matched.push( j );
}
}
}
for( j = 0, jl = matched.length; j < jl; j++ ) {
this.shoestringData.events[ evt ].splice( j, 1 );
}
}
function unbindAll( namespace, callback ) {
for( var evtKey in this.shoestringData.events ) {
unbind.call( this, evtKey, namespace, callback );
}
}
shoestring.fn.off = shoestring.fn.unbind;
/**
* Bind a callback to an event for the currrent set of elements, unbind after one occurence.
*
* @param {string} event The event(s) to watch for.
* @param {function} callback Callback to invoke on the event.
* @return shoestring
* @this shoestring
*/
shoestring.fn.one = function( event, callback ){
var evts = event.split( " " );
return this.each(function(){
var thisevt, cbs = {}, $t = shoestring( this );
for( var i = 0, il = evts.length; i < il; i++ ){
thisevt = evts[ i ];
cbs[ thisevt ] = function( e ){
var $t = shoestring( this );
for( var j in cbs ) {
$t.unbind( j, cbs[ j ] );
}
return callback.apply( this, [ e ].concat( e._args ) );
};
$t.bind( thisevt, cbs[ thisevt ] );
}
});
};
/**
* Trigger an event on the first element in the set, no bubbling, no defaults.
*
* @param {string} event The event(s) to trigger.
* @param {object} args Arguments to append to callback invocations.
* @return shoestring
* @this shoestring
*/
shoestring.fn.triggerHandler = function( event, args ){
var e = event.split( " " )[ 0 ],
el = this[ 0 ],
ret;
// See this.fireEvent( 'on' + evts[ i ], document.createEventObject() ); instead of click() etc in trigger.
if( doc.createEvent && el.shoestringData && el.shoestringData.events && el.shoestringData.events[ e ] ){
var bindings = el.shoestringData.events[ e ];
for (var i in bindings ){
if( bindings.hasOwnProperty( i ) ){
event = doc.createEvent( "Event" );
event.initEvent( e, true, true );
event._args = args;
args.unshift( event );
ret = bindings[ i ].originalCallback.apply( event.target, args );
}
}
}
return ret;
};
/**
* Trigger an event on each of the DOM elements in the current set.
*
* @param {string} event The event(s) to trigger.
* @param {object} args Arguments to append to callback invocations.
* @return shoestring
* @this shoestring
*/
shoestring.fn.trigger = function( event, args ){
var evts = event.split( " " );
return this.each(function(){
var split, evt, namespace;
for( var i = 0, il = evts.length; i < il; i++ ){
split = evts[ i ].split( "." ),
evt = split[ 0 ],
namespace = split.length > 0 ? split[ 1 ] : null;
if( evt === "click" ){
if( this.tagName === "INPUT" && this.type === "checkbox" && this.click ){
this.click();
return false;
}
}
if( doc.createEvent ){
var event = doc.createEvent( "Event" );
event.initEvent( evt, true, true );
event._args = args;
event._namespace = namespace;
this.dispatchEvent( event );
}
}
});
};
shoestring.fn.hasClass = function(){
shoestring.error( 'has-class' );
};
shoestring.fn.hide = function(){
shoestring.error( 'show-hide' );
};
shoestring.fn.outerWidth = function(){
shoestring.error( 'outer-width' );
};
shoestring.fn.show = function(){
shoestring.error( 'show-hide' );
};
shoestring.fn.click = function(){
shoestring.error( 'click' );
};
shoestring.map = function(){
shoestring.error( 'map' );
};
shoestring.fn.map = function(){
shoestring.error( 'map' );
};
shoestring.trim = function(){
shoestring.error( 'trim' );
};
(function() {
shoestring.trackedMethodsKey = "shoestringMethods";
// simple check for localStorage from Modernizr - https://github.com/Modernizr/Modernizr/blob/master/feature-detects/storage/localstorage.js
function supportsStorage() {
var mod = "modernizr";
try {
localStorage.setItem(mod, mod);
localStorage.removeItem(mod);
return true;
} catch(e) {
return false;
}
}
// return a new function closed over the old implementation
function recordProxy( old, name ) {
return function() {
var tracked;
try {
tracked = JSON.parse(win.localStorage.getItem( shoestring.trackedMethodsKey ) || "{}");
} catch (e) {
if( e instanceof SyntaxError) {
tracked = {};
}
}
tracked[ name ] = true;
win.localStorage.setItem( shoestring.trackedMethodsKey, JSON.stringify(tracked) );
return old.apply(this, arguments);
};
}
// proxy each of the methods defined on fn
if( supportsStorage() ){
for( var method in shoestring.fn ){
if( shoestring.fn.hasOwnProperty(method) ) {
shoestring.fn[ method ] = recordProxy(shoestring.fn[ method ], method);
}
}
}
})();
return shoestring;
}));