added vendor directory and gulp support for better dependency organization and compiling less and js files
removed timeline css and merged it with the theme css and added gulp support for a browser sync task as well for easier development removed composer package until the repo issue is resolved - added minified versions into the bower.json for when the repo issue is resolved
This commit is contained in:
David Miller
223
bower_components/jquery/src/callbacks.js
vendored
223
bower_components/jquery/src/callbacks.js
vendored
@@ -1,17 +1,16 @@
|
||||
define([
|
||||
define( [
|
||||
"./core",
|
||||
"./var/rnotwhite"
|
||||
], function( jQuery, rnotwhite ) {
|
||||
|
||||
// String to Object options format cache
|
||||
var optionsCache = {};
|
||||
"use strict";
|
||||
|
||||
// Convert String-formatted options into Object-formatted ones and store in cache
|
||||
// Convert String-formatted options into Object-formatted ones
|
||||
function createOptions( options ) {
|
||||
var object = optionsCache[ options ] = {};
|
||||
var object = {};
|
||||
jQuery.each( options.match( rnotwhite ) || [], function( _, flag ) {
|
||||
object[ flag ] = true;
|
||||
});
|
||||
} );
|
||||
return object;
|
||||
}
|
||||
|
||||
@@ -42,156 +41,186 @@ jQuery.Callbacks = function( options ) {
|
||||
// Convert options from String-formatted to Object-formatted if needed
|
||||
// (we check in cache first)
|
||||
options = typeof options === "string" ?
|
||||
( optionsCache[ options ] || createOptions( options ) ) :
|
||||
createOptions( options ) :
|
||||
jQuery.extend( {}, options );
|
||||
|
||||
var // Last fire value (for non-forgettable lists)
|
||||
var // Flag to know if list is currently firing
|
||||
firing,
|
||||
|
||||
// Last fire value for non-forgettable lists
|
||||
memory,
|
||||
|
||||
// Flag to know if list was already fired
|
||||
fired,
|
||||
// Flag to know if list is currently firing
|
||||
firing,
|
||||
// First callback to fire (used internally by add and fireWith)
|
||||
firingStart,
|
||||
// End of the loop when firing
|
||||
firingLength,
|
||||
// Index of currently firing callback (modified by remove if needed)
|
||||
firingIndex,
|
||||
|
||||
// Flag to prevent firing
|
||||
locked,
|
||||
|
||||
// Actual callback list
|
||||
list = [],
|
||||
// Stack of fire calls for repeatable lists
|
||||
stack = !options.once && [],
|
||||
|
||||
// Queue of execution data for repeatable lists
|
||||
queue = [],
|
||||
|
||||
// Index of currently firing callback (modified by add/remove as needed)
|
||||
firingIndex = -1,
|
||||
|
||||
// Fire callbacks
|
||||
fire = function( data ) {
|
||||
memory = options.memory && data;
|
||||
fired = true;
|
||||
firingIndex = firingStart || 0;
|
||||
firingStart = 0;
|
||||
firingLength = list.length;
|
||||
firing = true;
|
||||
for ( ; list && firingIndex < firingLength; firingIndex++ ) {
|
||||
if ( list[ firingIndex ].apply( data[ 0 ], data[ 1 ] ) === false && options.stopOnFalse ) {
|
||||
memory = false; // To prevent further calls using add
|
||||
break;
|
||||
fire = function() {
|
||||
|
||||
// Enforce single-firing
|
||||
locked = options.once;
|
||||
|
||||
// Execute callbacks for all pending executions,
|
||||
// respecting firingIndex overrides and runtime changes
|
||||
fired = firing = true;
|
||||
for ( ; queue.length; firingIndex = -1 ) {
|
||||
memory = queue.shift();
|
||||
while ( ++firingIndex < list.length ) {
|
||||
|
||||
// Run callback and check for early termination
|
||||
if ( list[ firingIndex ].apply( memory[ 0 ], memory[ 1 ] ) === false &&
|
||||
options.stopOnFalse ) {
|
||||
|
||||
// Jump to end and forget the data so .add doesn't re-fire
|
||||
firingIndex = list.length;
|
||||
memory = false;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Forget the data if we're done with it
|
||||
if ( !options.memory ) {
|
||||
memory = false;
|
||||
}
|
||||
|
||||
firing = false;
|
||||
if ( list ) {
|
||||
if ( stack ) {
|
||||
if ( stack.length ) {
|
||||
fire( stack.shift() );
|
||||
}
|
||||
} else if ( memory ) {
|
||||
|
||||
// Clean up if we're done firing for good
|
||||
if ( locked ) {
|
||||
|
||||
// Keep an empty list if we have data for future add calls
|
||||
if ( memory ) {
|
||||
list = [];
|
||||
|
||||
// Otherwise, this object is spent
|
||||
} else {
|
||||
self.disable();
|
||||
list = "";
|
||||
}
|
||||
}
|
||||
},
|
||||
|
||||
// Actual Callbacks object
|
||||
self = {
|
||||
|
||||
// Add a callback or a collection of callbacks to the list
|
||||
add: function() {
|
||||
if ( list ) {
|
||||
// First, we save the current length
|
||||
var start = list.length;
|
||||
(function add( args ) {
|
||||
|
||||
// If we have memory from a past run, we should fire after adding
|
||||
if ( memory && !firing ) {
|
||||
firingIndex = list.length - 1;
|
||||
queue.push( memory );
|
||||
}
|
||||
|
||||
( function add( args ) {
|
||||
jQuery.each( args, function( _, arg ) {
|
||||
var type = jQuery.type( arg );
|
||||
if ( type === "function" ) {
|
||||
if ( jQuery.isFunction( arg ) ) {
|
||||
if ( !options.unique || !self.has( arg ) ) {
|
||||
list.push( arg );
|
||||
}
|
||||
} else if ( arg && arg.length && type !== "string" ) {
|
||||
} else if ( arg && arg.length && jQuery.type( arg ) !== "string" ) {
|
||||
|
||||
// Inspect recursively
|
||||
add( arg );
|
||||
}
|
||||
});
|
||||
})( arguments );
|
||||
// Do we need to add the callbacks to the
|
||||
// current firing batch?
|
||||
if ( firing ) {
|
||||
firingLength = list.length;
|
||||
// With memory, if we're not firing then
|
||||
// we should call right away
|
||||
} else if ( memory ) {
|
||||
firingStart = start;
|
||||
fire( memory );
|
||||
} );
|
||||
} )( arguments );
|
||||
|
||||
if ( memory && !firing ) {
|
||||
fire();
|
||||
}
|
||||
}
|
||||
return this;
|
||||
},
|
||||
|
||||
// Remove a callback from the list
|
||||
remove: function() {
|
||||
if ( list ) {
|
||||
jQuery.each( arguments, function( _, arg ) {
|
||||
var index;
|
||||
while ( ( index = jQuery.inArray( arg, list, index ) ) > -1 ) {
|
||||
list.splice( index, 1 );
|
||||
// Handle firing indexes
|
||||
if ( firing ) {
|
||||
if ( index <= firingLength ) {
|
||||
firingLength--;
|
||||
}
|
||||
if ( index <= firingIndex ) {
|
||||
firingIndex--;
|
||||
}
|
||||
}
|
||||
jQuery.each( arguments, function( _, arg ) {
|
||||
var index;
|
||||
while ( ( index = jQuery.inArray( arg, list, index ) ) > -1 ) {
|
||||
list.splice( index, 1 );
|
||||
|
||||
// Handle firing indexes
|
||||
if ( index <= firingIndex ) {
|
||||
firingIndex--;
|
||||
}
|
||||
});
|
||||
}
|
||||
}
|
||||
} );
|
||||
return this;
|
||||
},
|
||||
|
||||
// Check if a given callback is in the list.
|
||||
// If no argument is given, return whether or not list has callbacks attached.
|
||||
has: function( fn ) {
|
||||
return fn ? jQuery.inArray( fn, list ) > -1 : !!( list && list.length );
|
||||
return fn ?
|
||||
jQuery.inArray( fn, list ) > -1 :
|
||||
list.length > 0;
|
||||
},
|
||||
|
||||
// Remove all callbacks from the list
|
||||
empty: function() {
|
||||
list = [];
|
||||
firingLength = 0;
|
||||
return this;
|
||||
},
|
||||
// Have the list do nothing anymore
|
||||
disable: function() {
|
||||
list = stack = memory = undefined;
|
||||
return this;
|
||||
},
|
||||
// Is it disabled?
|
||||
disabled: function() {
|
||||
return !list;
|
||||
},
|
||||
// Lock the list in its current state
|
||||
lock: function() {
|
||||
stack = undefined;
|
||||
if ( !memory ) {
|
||||
self.disable();
|
||||
if ( list ) {
|
||||
list = [];
|
||||
}
|
||||
return this;
|
||||
},
|
||||
// Is it locked?
|
||||
locked: function() {
|
||||
return !stack;
|
||||
|
||||
// Disable .fire and .add
|
||||
// Abort any current/pending executions
|
||||
// Clear all callbacks and values
|
||||
disable: function() {
|
||||
locked = queue = [];
|
||||
list = memory = "";
|
||||
return this;
|
||||
},
|
||||
disabled: function() {
|
||||
return !list;
|
||||
},
|
||||
|
||||
// Disable .fire
|
||||
// Also disable .add unless we have memory (since it would have no effect)
|
||||
// Abort any pending executions
|
||||
lock: function() {
|
||||
locked = queue = [];
|
||||
if ( !memory && !firing ) {
|
||||
list = memory = "";
|
||||
}
|
||||
return this;
|
||||
},
|
||||
locked: function() {
|
||||
return !!locked;
|
||||
},
|
||||
|
||||
// Call all callbacks with the given context and arguments
|
||||
fireWith: function( context, args ) {
|
||||
if ( list && ( !fired || stack ) ) {
|
||||
if ( !locked ) {
|
||||
args = args || [];
|
||||
args = [ context, args.slice ? args.slice() : args ];
|
||||
if ( firing ) {
|
||||
stack.push( args );
|
||||
} else {
|
||||
fire( args );
|
||||
queue.push( args );
|
||||
if ( !firing ) {
|
||||
fire();
|
||||
}
|
||||
}
|
||||
return this;
|
||||
},
|
||||
|
||||
// Call all the callbacks with the given arguments
|
||||
fire: function() {
|
||||
self.fireWith( this, arguments );
|
||||
return this;
|
||||
},
|
||||
|
||||
// To know if the callbacks have already been called at least once
|
||||
fired: function() {
|
||||
return !!fired;
|
||||
@@ -202,4 +231,4 @@ jQuery.Callbacks = function( options ) {
|
||||
};
|
||||
|
||||
return jQuery;
|
||||
});
|
||||
} );
|
||||
|
||||
Reference in New Issue
Block a user