root / drupal7 / sites / all / libraries / flexslider-2.5.0 / bower_components / jquery / src / callbacks.js @ 0aee3c58
| 1 |
define([ |
|---|---|
| 2 |
"./core",
|
| 3 |
"./var/rnotwhite"
|
| 4 |
], function( jQuery, rnotwhite ) {
|
| 5 |
|
| 6 |
// String to Object options format cache
|
| 7 |
var optionsCache = {};
|
| 8 |
|
| 9 |
// Convert String-formatted options into Object-formatted ones and store in cache
|
| 10 |
function createOptions( options ) { |
| 11 |
var object = optionsCache[ options ] = {};
|
| 12 |
jQuery.each( options.match( rnotwhite ) || [], function( _, flag ) {
|
| 13 |
object[ flag ] = true;
|
| 14 |
}); |
| 15 |
return object;
|
| 16 |
} |
| 17 |
|
| 18 |
/*
|
| 19 |
* Create a callback list using the following parameters:
|
| 20 |
*
|
| 21 |
* options: an optional list of space-separated options that will change how
|
| 22 |
* the callback list behaves or a more traditional option object
|
| 23 |
*
|
| 24 |
* By default a callback list will act like an event callback list and can be
|
| 25 |
* "fired" multiple times.
|
| 26 |
*
|
| 27 |
* Possible options:
|
| 28 |
*
|
| 29 |
* once: will ensure the callback list can only be fired once (like a Deferred)
|
| 30 |
*
|
| 31 |
* memory: will keep track of previous values and will call any callback added
|
| 32 |
* after the list has been fired right away with the latest "memorized"
|
| 33 |
* values (like a Deferred)
|
| 34 |
*
|
| 35 |
* unique: will ensure a callback can only be added once (no duplicate in the list)
|
| 36 |
*
|
| 37 |
* stopOnFalse: interrupt callings when a callback returns false
|
| 38 |
*
|
| 39 |
*/
|
| 40 |
jQuery.Callbacks = function( options ) { |
| 41 |
|
| 42 |
// Convert options from String-formatted to Object-formatted if needed
|
| 43 |
// (we check in cache first)
|
| 44 |
options = typeof options === "string" ? |
| 45 |
( optionsCache[ options ] || createOptions( options ) ) : |
| 46 |
jQuery.extend( {}, options );
|
| 47 |
|
| 48 |
var // Flag to know if list is currently firing |
| 49 |
firing, |
| 50 |
// Last fire value (for non-forgettable lists)
|
| 51 |
memory, |
| 52 |
// Flag to know if list was already fired
|
| 53 |
fired, |
| 54 |
// End of the loop when firing
|
| 55 |
firingLength, |
| 56 |
// Index of currently firing callback (modified by remove if needed)
|
| 57 |
firingIndex, |
| 58 |
// First callback to fire (used internally by add and fireWith)
|
| 59 |
firingStart, |
| 60 |
// Actual callback list
|
| 61 |
list = [], |
| 62 |
// Stack of fire calls for repeatable lists
|
| 63 |
stack = !options.once && [], |
| 64 |
// Fire callbacks
|
| 65 |
fire = function( data ) { |
| 66 |
memory = options.memory && data; |
| 67 |
fired = true;
|
| 68 |
firingIndex = firingStart || 0;
|
| 69 |
firingStart = 0;
|
| 70 |
firingLength = list.length; |
| 71 |
firing = true;
|
| 72 |
for ( ; list && firingIndex < firingLength; firingIndex++ ) {
|
| 73 |
if ( list[ firingIndex ].apply( data[ 0 ], data[ 1 ] ) === false && options.stopOnFalse ) { |
| 74 |
memory = false; // To prevent further calls using add |
| 75 |
break;
|
| 76 |
} |
| 77 |
} |
| 78 |
firing = false;
|
| 79 |
if ( list ) {
|
| 80 |
if ( stack ) {
|
| 81 |
if ( stack.length ) {
|
| 82 |
fire( stack.shift() ); |
| 83 |
} |
| 84 |
} else if ( memory ) { |
| 85 |
list = []; |
| 86 |
} else {
|
| 87 |
self.disable(); |
| 88 |
} |
| 89 |
} |
| 90 |
}, |
| 91 |
// Actual Callbacks object
|
| 92 |
self = {
|
| 93 |
// Add a callback or a collection of callbacks to the list
|
| 94 |
add: function() { |
| 95 |
if ( list ) {
|
| 96 |
// First, we save the current length
|
| 97 |
var start = list.length;
|
| 98 |
(function add( args ) { |
| 99 |
jQuery.each( args, function( _, arg ) {
|
| 100 |
var type = jQuery.type( arg );
|
| 101 |
if ( type === "function" ) { |
| 102 |
if ( !options.unique || !self.has( arg ) ) {
|
| 103 |
list.push( arg ); |
| 104 |
} |
| 105 |
} else if ( arg && arg.length && type !== "string" ) { |
| 106 |
// Inspect recursively
|
| 107 |
add( arg ); |
| 108 |
} |
| 109 |
}); |
| 110 |
})( arguments );
|
| 111 |
// Do we need to add the callbacks to the
|
| 112 |
// current firing batch?
|
| 113 |
if ( firing ) {
|
| 114 |
firingLength = list.length; |
| 115 |
// With memory, if we're not firing then
|
| 116 |
// we should call right away
|
| 117 |
} else if ( memory ) { |
| 118 |
firingStart = start; |
| 119 |
fire( memory ); |
| 120 |
} |
| 121 |
} |
| 122 |
return this; |
| 123 |
}, |
| 124 |
// Remove a callback from the list
|
| 125 |
remove: function() { |
| 126 |
if ( list ) {
|
| 127 |
jQuery.each( arguments, function( _, arg ) { |
| 128 |
var index;
|
| 129 |
while ( ( index = jQuery.inArray( arg, list, index ) ) > -1 ) { |
| 130 |
list.splice( index, 1 );
|
| 131 |
// Handle firing indexes
|
| 132 |
if ( firing ) {
|
| 133 |
if ( index <= firingLength ) {
|
| 134 |
firingLength--; |
| 135 |
} |
| 136 |
if ( index <= firingIndex ) {
|
| 137 |
firingIndex--; |
| 138 |
} |
| 139 |
} |
| 140 |
} |
| 141 |
}); |
| 142 |
} |
| 143 |
return this; |
| 144 |
}, |
| 145 |
// Check if a given callback is in the list.
|
| 146 |
// If no argument is given, return whether or not list has callbacks attached.
|
| 147 |
has: function( fn ) { |
| 148 |
return fn ? jQuery.inArray( fn, list ) > -1 : !!( list && list.length ); |
| 149 |
}, |
| 150 |
// Remove all callbacks from the list
|
| 151 |
empty: function() { |
| 152 |
list = []; |
| 153 |
firingLength = 0;
|
| 154 |
return this; |
| 155 |
}, |
| 156 |
// Have the list do nothing anymore
|
| 157 |
disable: function() { |
| 158 |
list = stack = memory = undefined;
|
| 159 |
return this; |
| 160 |
}, |
| 161 |
// Is it disabled?
|
| 162 |
disabled: function() { |
| 163 |
return !list;
|
| 164 |
}, |
| 165 |
// Lock the list in its current state
|
| 166 |
lock: function() { |
| 167 |
stack = undefined;
|
| 168 |
if ( !memory ) {
|
| 169 |
self.disable(); |
| 170 |
} |
| 171 |
return this; |
| 172 |
}, |
| 173 |
// Is it locked?
|
| 174 |
locked: function() { |
| 175 |
return !stack;
|
| 176 |
}, |
| 177 |
// Call all callbacks with the given context and arguments
|
| 178 |
fireWith: function( context, args ) { |
| 179 |
if ( list && ( !fired || stack ) ) {
|
| 180 |
args = args || []; |
| 181 |
args = [ context, args.slice ? args.slice() : args ]; |
| 182 |
if ( firing ) {
|
| 183 |
stack.push( args ); |
| 184 |
} else {
|
| 185 |
fire( args ); |
| 186 |
} |
| 187 |
} |
| 188 |
return this; |
| 189 |
}, |
| 190 |
// Call all the callbacks with the given arguments
|
| 191 |
fire: function() { |
| 192 |
self.fireWith( this, arguments ); |
| 193 |
return this; |
| 194 |
}, |
| 195 |
// To know if the callbacks have already been called at least once
|
| 196 |
fired: function() { |
| 197 |
return !!fired;
|
| 198 |
} |
| 199 |
}; |
| 200 |
|
| 201 |
return self;
|
| 202 |
}; |
| 203 |
|
| 204 |
return jQuery;
|
| 205 |
}); |