tools/side_chain_tool/web/node_modules/jquery/src/callbacks.js

   1 define( [
   2         "./core",
   3         "./core/toType",
   4         "./var/isFunction",
   5         "./var/rnothtmlwhite"
   6 ], function( jQuery, toType, isFunction, rnothtmlwhite ) {
   7
   8 "use strict";
   9
  10 // Convert String-formatted options into Object-formatted ones
  11 function createOptions( options ) {
  12         var object = {};
  13         jQuery.each( options.match( rnothtmlwhite ) || [], function( _, flag ) {
  14                 object[ flag ] = true;
  15         } );
  16         return object;
  17 }
  18
  19 /*
  20  * Create a callback list using the following parameters:
  21  *
  22  *      options: an optional list of space-separated options that will change how
  23  *                      the callback list behaves or a more traditional option object
  24  *
  25  * By default a callback list will act like an event callback list and can be
  26  * "fired" multiple times.
  27  *
  28  * Possible options:
  29  *
  30  *      once:                   will ensure the callback list can only be fired once (like a Deferred)
  31  *
  32  *      memory:                 will keep track of previous values and will call any callback added
  33  *                                      after the list has been fired right away with the latest "memorized"
  34  *                                      values (like a Deferred)
  35  *
  36  *      unique:                 will ensure a callback can only be added once (no duplicate in the list)
  37  *
  38  *      stopOnFalse:    interrupt callings when a callback returns false
  39  *
  40  */
  41 jQuery.Callbacks = function( options ) {
  42
  43         // Convert options from String-formatted to Object-formatted if needed
  44         // (we check in cache first)
  45         options = typeof options === "string" ?
  46                 createOptions( options ) :
  47                 jQuery.extend( {}, options );
  48
  49         var // Flag to know if list is currently firing
  50                 firing,
  51
  52                 // Last fire value for non-forgettable lists
  53                 memory,
  54
  55                 // Flag to know if list was already fired
  56                 fired,
  57
  58                 // Flag to prevent firing
  59                 locked,
  60
  61                 // Actual callback list
  62                 list = [],
  63
  64                 // Queue of execution data for repeatable lists
  65                 queue = [],
  66
  67                 // Index of currently firing callback (modified by add/remove as needed)
  68                 firingIndex = -1,
  69
  70                 // Fire callbacks
  71                 fire = function() {
  72
  73                         // Enforce single-firing
  74                         locked = locked || options.once;
  75
  76                         // Execute callbacks for all pending executions,
  77                         // respecting firingIndex overrides and runtime changes
  78                         fired = firing = true;
  79                         for ( ; queue.length; firingIndex = -1 ) {
  80                                 memory = queue.shift();
  81                                 while ( ++firingIndex < list.length ) {
  82
  83                                         // Run callback and check for early termination
  84                                         if ( list[ firingIndex ].apply( memory[ 0 ], memory[ 1 ] ) === false &&
  85                                                 options.stopOnFalse ) {
  86
  87                                                 // Jump to end and forget the data so .add doesn't re-fire
  88                                                 firingIndex = list.length;
  89                                                 memory = false;
  90                                         }
  91                                 }
  92                         }
  93
  94                         // Forget the data if we're done with it
  95                         if ( !options.memory ) {
  96                                 memory = false;
  97                         }
  98
  99                         firing = false;
 100
 101                         // Clean up if we're done firing for good
 102                         if ( locked ) {
 103
 104                                 // Keep an empty list if we have data for future add calls
 105                                 if ( memory ) {
 106                                         list = [];
 107
 108                                 // Otherwise, this object is spent
 109                                 } else {
 110                                         list = "";
 111                                 }
 112                         }
 113                 },
 114
 115                 // Actual Callbacks object
 116                 self = {
 117
 118                         // Add a callback or a collection of callbacks to the list
 119                         add: function() {
 120                                 if ( list ) {
 121
 122                                         // If we have memory from a past run, we should fire after adding
 123                                         if ( memory && !firing ) {
 124                                                 firingIndex = list.length - 1;
 125                                                 queue.push( memory );
 126                                         }
 127
 128                                         ( function add( args ) {
 129                                                 jQuery.each( args, function( _, arg ) {
 130                                                         if ( isFunction( arg ) ) {
 131                                                                 if ( !options.unique || !self.has( arg ) ) {
 132                                                                         list.push( arg );
 133                                                                 }
 134                                                         } else if ( arg && arg.length && toType( arg ) !== "string" ) {
 135
 136                                                                 // Inspect recursively
 137                                                                 add( arg );
 138                                                         }
 139                                                 } );
 140                                         } )( arguments );
 141
 142                                         if ( memory && !firing ) {
 143                                                 fire();
 144                                         }
 145                                 }
 146                                 return this;
 147                         },
 148
 149                         // Remove a callback from the list
 150                         remove: function() {
 151                                 jQuery.each( arguments, function( _, arg ) {
 152                                         var index;
 153                                         while ( ( index = jQuery.inArray( arg, list, index ) ) > -1 ) {
 154                                                 list.splice( index, 1 );
 155
 156                                                 // Handle firing indexes
 157                                                 if ( index <= firingIndex ) {
 158                                                         firingIndex--;
 159                                                 }
 160                                         }
 161                                 } );
 162                                 return this;
 163                         },
 164
 165                         // Check if a given callback is in the list.
 166                         // If no argument is given, return whether or not list has callbacks attached.
 167                         has: function( fn ) {
 168                                 return fn ?
 169                                         jQuery.inArray( fn, list ) > -1 :
 170                                         list.length > 0;
 171                         },
 172
 173                         // Remove all callbacks from the list
 174                         empty: function() {
 175                                 if ( list ) {
 176                                         list = [];
 177                                 }
 178                                 return this;
 179                         },
 180
 181                         // Disable .fire and .add
 182                         // Abort any current/pending executions
 183                         // Clear all callbacks and values
 184                         disable: function() {
 185                                 locked = queue = [];
 186                                 list = memory = "";
 187                                 return this;
 188                         },
 189                         disabled: function() {
 190                                 return !list;
 191                         },
 192
 193                         // Disable .fire
 194                         // Also disable .add unless we have memory (since it would have no effect)
 195                         // Abort any pending executions
 196                         lock: function() {
 197                                 locked = queue = [];
 198                                 if ( !memory && !firing ) {
 199                                         list = memory = "";
 200                                 }
 201                                 return this;
 202                         },
 203                         locked: function() {
 204                                 return !!locked;
 205                         },
 206
 207                         // Call all callbacks with the given context and arguments
 208                         fireWith: function( context, args ) {
 209                                 if ( !locked ) {
 210                                         args = args || [];
 211                                         args = [ context, args.slice ? args.slice() : args ];
 212                                         queue.push( args );
 213                                         if ( !firing ) {
 214                                                 fire();
 215                                         }
 216                                 }
 217                                 return this;
 218                         },
 219
 220                         // Call all the callbacks with the given arguments
 221                         fire: function() {
 222                                 self.fireWith( this, arguments );
 223                                 return this;
 224                         },
 225
 226                         // To know if the callbacks have already been called at least once
 227                         fired: function() {
 228                                 return !!fired;
 229                         }
 230                 };
 231
 232         return self;
 233 };
 234
 235 return jQuery;
 236 } );