src/core.js

   1 define([
   2         "./var/arr",
   3         "./var/document",
   4         "./var/slice",
   5         "./var/concat",
   6         "./var/push",
   7         "./var/indexOf",
   8         "./var/class2type",
   9         "./var/toString",
  10         "./var/hasOwn",
  11         "./var/support"
  12 ], function( arr, document, slice, concat, push, indexOf, class2type, toString, hasOwn, support ) {
  13
  14 var
  15         version = "@VERSION",
  16
  17         // Define a local copy of jQuery
  18         jQuery = function( selector, context ) {
  19                 // The jQuery object is actually just the init constructor 'enhanced'
  20                 // Need init if jQuery is called (just allow error to be thrown if not included)
  21                 return new jQuery.fn.init( selector, context );
  22         },
  23
  24         // Support: Android<4.1
  25         // Make sure we trim BOM and NBSP
  26         rtrim = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g,
  27
  28         // Matches dashed string for camelizing
  29         rmsPrefix = /^-ms-/,
  30         rdashAlpha = /-([\da-z])/gi,
  31
  32         // Used by jQuery.camelCase as callback to replace()
  33         fcamelCase = function( all, letter ) {
  34                 return letter.toUpperCase();
  35         };
  36
  37 jQuery.fn = jQuery.prototype = {
  38         // The current version of jQuery being used
  39         jquery: version,
  40
  41         constructor: jQuery,
  42
  43         // The default length of a jQuery object is 0
  44         length: 0,
  45
  46         toArray: function() {
  47                 return slice.call( this );
  48         },
  49
  50         // Get the Nth element in the matched element set OR
  51         // Get the whole matched element set as a clean array
  52         get: function( num ) {
  53                 return num != null ?
  54
  55                         // Return just the one element from the set
  56                         ( num < 0 ? this[ num + this.length ] : this[ num ] ) :
  57
  58                         // Return all the elements in a clean array
  59                         slice.call( this );
  60         },
  61
  62         // Take an array of elements and push it onto the stack
  63         // (returning the new matched element set)
  64         pushStack: function( elems ) {
  65
  66                 // Build a new jQuery matched element set
  67                 var ret = jQuery.merge( this.constructor(), elems );
  68
  69                 // Add the old object onto the stack (as a reference)
  70                 ret.prevObject = this;
  71
  72                 // Return the newly-formed element set
  73                 return ret;
  74         },
  75
  76         // Execute a callback for every element in the matched set.
  77         // (You can seed the arguments with an array of args, but this is
  78         // only used internally.)
  79         each: function( callback, args ) {
  80                 return jQuery.each( this, callback, args );
  81         },
  82
  83         map: function( callback ) {
  84                 return this.pushStack( jQuery.map(this, function( elem, i ) {
  85                         return callback.call( elem, i, elem );
  86                 }));
  87         },
  88
  89         slice: function() {
  90                 return this.pushStack( slice.apply( this, arguments ) );
  91         },
  92
  93         first: function() {
  94                 return this.eq( 0 );
  95         },
  96
  97         last: function() {
  98                 return this.eq( -1 );
  99         },
 100
 101         eq: function( i ) {
 102                 var len = this.length,
 103                         j = +i + ( i < 0 ? len : 0 );
 104                 return this.pushStack( j >= 0 && j < len ? [ this[j] ] : [] );
 105         },
 106
 107         end: function() {
 108                 return this.prevObject || this.constructor(null);
 109         },
 110
 111         // For internal use only.
 112         // Behaves like an Array's method, not like a jQuery method.
 113         push: push,
 114         sort: arr.sort,
 115         splice: arr.splice
 116 };
 117
 118 jQuery.extend = jQuery.fn.extend = function() {
 119         var options, name, src, copy, copyIsArray, clone,
 120                 target = arguments[0] || {},
 121                 i = 1,
 122                 length = arguments.length,
 123                 deep = false;
 124
 125         // Handle a deep copy situation
 126         if ( typeof target === "boolean" ) {
 127                 deep = target;
 128
 129                 // Skip the boolean and the target
 130                 target = arguments[ i ] || {};
 131                 i++;
 132         }
 133
 134         // Handle case when target is a string or something (possible in deep copy)
 135         if ( typeof target !== "object" && !jQuery.isFunction(target) ) {
 136                 target = {};
 137         }
 138
 139         // Extend jQuery itself if only one argument is passed
 140         if ( i === length ) {
 141                 target = this;
 142                 i--;
 143         }
 144
 145         for ( ; i < length; i++ ) {
 146                 // Only deal with non-null/undefined values
 147                 if ( (options = arguments[ i ]) != null ) {
 148                         // Extend the base object
 149                         for ( name in options ) {
 150                                 src = target[ name ];
 151                                 copy = options[ name ];
 152
 153                                 // Prevent never-ending loop
 154                                 if ( target === copy ) {
 155                                         continue;
 156                                 }
 157
 158                                 // Recurse if we're merging plain objects or arrays
 159                                 if ( deep && copy && ( jQuery.isPlainObject(copy) ||
 160                                         (copyIsArray = jQuery.isArray(copy)) ) ) {
 161
 162                                         if ( copyIsArray ) {
 163                                                 copyIsArray = false;
 164                                                 clone = src && jQuery.isArray(src) ? src : [];
 165
 166                                         } else {
 167                                                 clone = src && jQuery.isPlainObject(src) ? src : {};
 168                                         }
 169
 170                                         // Never move original objects, clone them
 171                                         target[ name ] = jQuery.extend( deep, clone, copy );
 172
 173                                 // Don't bring in undefined values
 174                                 } else if ( copy !== undefined ) {
 175                                         target[ name ] = copy;
 176                                 }
 177                         }
 178                 }
 179         }
 180
 181         // Return the modified object
 182         return target;
 183 };
 184
 185 jQuery.extend({
 186         // Unique for each copy of jQuery on the page
 187         expando: "jQuery" + ( version + Math.random() ).replace( /\D/g, "" ),
 188
 189         // Assume jQuery is ready without the ready module
 190         isReady: true,
 191
 192         error: function( msg ) {
 193                 throw new Error( msg );
 194         },
 195
 196         noop: function() {},
 197
 198         isFunction: function( obj ) {
 199                 return jQuery.type(obj) === "function";
 200         },
 201
 202         isArray: Array.isArray,
 203
 204         isWindow: function( obj ) {
 205                 return obj != null && obj === obj.window;
 206         },
 207
 208         isNumeric: function( obj ) {
 209                 // parseFloat NaNs numeric-cast false positives (null|true|false|"")
 210                 // ...but misinterprets leading-number strings, particularly hex literals ("0x...")
 211                 // subtraction forces infinities to NaN
 212                 // adding 1 corrects loss of precision from parseFloat (#15100)
 213                 return !jQuery.isArray( obj ) && (obj - parseFloat( obj ) + 1) >= 0;
 214         },
 215
 216         isPlainObject: function( obj ) {
 217                 // Not plain objects:
 218                 // - Any object or value whose internal [[Class]] property is not "[object Object]"
 219                 // - DOM nodes
 220                 // - window
 221                 if ( jQuery.type( obj ) !== "object" || obj.nodeType || jQuery.isWindow( obj ) ) {
 222                         return false;
 223                 }
 224
 225                 if ( obj.constructor &&
 226                                 !hasOwn.call( obj.constructor.prototype, "isPrototypeOf" ) ) {
 227                         return false;
 228                 }
 229
 230                 // If the function hasn't returned already, we're confident that
 231                 // |obj| is a plain object, created by {} or constructed with new Object
 232                 return true;
 233         },
 234
 235         isEmptyObject: function( obj ) {
 236                 var name;
 237                 for ( name in obj ) {
 238                         return false;
 239                 }
 240                 return true;
 241         },
 242
 243         type: function( obj ) {
 244                 if ( obj == null ) {
 245                         return obj + "";
 246                 }
 247                 // Support: Android<4.0 (functionish RegExp)
 248                 return typeof obj === "object" || typeof obj === "function" ?
 249                         class2type[ toString.call(obj) ] || "object" :
 250                         typeof obj;
 251         },
 252
 253         // Evaluates a script in a global context
 254         globalEval: function( code ) {
 255                 var script = document.createElement( "script" );
 256
 257                 script.text = code;
 258                 document.head.appendChild( script ).parentNode.removeChild( script );
 259         },
 260
 261         // Convert dashed to camelCase; used by the css and data modules
 262         // Support: IE9-11+
 263         // Microsoft forgot to hump their vendor prefix (#9572)
 264         camelCase: function( string ) {
 265                 return string.replace( rmsPrefix, "ms-" ).replace( rdashAlpha, fcamelCase );
 266         },
 267
 268         nodeName: function( elem, name ) {
 269                 return elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase();
 270         },
 271
 272         // args is for internal usage only
 273         each: function( obj, callback, args ) {
 274                 var i = 0,
 275                         length = obj.length,
 276                         isArray = isArraylike( obj );
 277
 278                 if ( args ) {
 279                         if ( isArray ) {
 280                                 for ( ; i < length; i++ ) {
 281                                         if ( callback.apply( obj[ i ], args ) === false ) {
 282                                                 break;
 283                                         }
 284                                 }
 285                         } else {
 286                                 for ( i in obj ) {
 287                                         if ( callback.apply( obj[ i ], args ) === false ) {
 288                                                 break;
 289                                         }
 290                                 }
 291                         }
 292
 293                 // A special, fast, case for the most common use of each
 294                 } else {
 295                         if ( isArray ) {
 296                                 for ( ; i < length; i++ ) {
 297                                         if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) {
 298                                                 break;
 299                                         }
 300                                 }
 301                         } else {
 302                                 for ( i in obj ) {
 303                                         if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) {
 304                                                 break;
 305                                         }
 306                                 }
 307                         }
 308                 }
 309
 310                 return obj;
 311         },
 312
 313         // Support: Android<4.1
 314         trim: function( text ) {
 315                 return text == null ?
 316                         "" :
 317                         ( text + "" ).replace( rtrim, "" );
 318         },
 319
 320         // results is for internal usage only
 321         makeArray: function( arr, results ) {
 322                 var ret = results || [];
 323
 324                 if ( arr != null ) {
 325                         if ( isArraylike( Object(arr) ) ) {
 326                                 jQuery.merge( ret,
 327                                         typeof arr === "string" ?
 328                                         [ arr ] : arr
 329                                 );
 330                         } else {
 331                                 push.call( ret, arr );
 332                         }
 333                 }
 334
 335                 return ret;
 336         },
 337
 338         inArray: function( elem, arr, i ) {
 339                 return arr == null ? -1 : indexOf.call( arr, elem, i );
 340         },
 341
 342         // Support: Android<4.1, PhantomJS<2
 343         // push.apply(_, arraylike) throws on ancient WebKit
 344         merge: function( first, second ) {
 345                 var len = +second.length,
 346                         j = 0,
 347                         i = first.length;
 348
 349                 for ( ; j < len; j++ ) {
 350                         first[ i++ ] = second[ j ];
 351                 }
 352
 353                 first.length = i;
 354
 355                 return first;
 356         },
 357
 358         grep: function( elems, callback, invert ) {
 359                 var callbackInverse,
 360                         matches = [],
 361                         i = 0,
 362                         length = elems.length,
 363                         callbackExpect = !invert;
 364
 365                 // Go through the array, only saving the items
 366                 // that pass the validator function
 367                 for ( ; i < length; i++ ) {
 368                         callbackInverse = !callback( elems[ i ], i );
 369                         if ( callbackInverse !== callbackExpect ) {
 370                                 matches.push( elems[ i ] );
 371                         }
 372                 }
 373
 374                 return matches;
 375         },
 376
 377         // arg is for internal usage only
 378         map: function( elems, callback, arg ) {
 379                 var value,
 380                         i = 0,
 381                         length = elems.length,
 382                         isArray = isArraylike( elems ),
 383                         ret = [];
 384
 385                 // Go through the array, translating each of the items to their new values
 386                 if ( isArray ) {
 387                         for ( ; i < length; i++ ) {
 388                                 value = callback( elems[ i ], i, arg );
 389
 390                                 if ( value != null ) {
 391                                         ret.push( value );
 392                                 }
 393                         }
 394
 395                 // Go through every key on the object,
 396                 } else {
 397                         for ( i in elems ) {
 398                                 value = callback( elems[ i ], i, arg );
 399
 400                                 if ( value != null ) {
 401                                         ret.push( value );
 402                                 }
 403                         }
 404                 }
 405
 406                 // Flatten any nested arrays
 407                 return concat.apply( [], ret );
 408         },
 409
 410         // A global GUID counter for objects
 411         guid: 1,
 412
 413         // Bind a function to a context, optionally partially applying any
 414         // arguments.
 415         proxy: function( fn, context ) {
 416                 var tmp, args, proxy;
 417
 418                 if ( typeof context === "string" ) {
 419                         tmp = fn[ context ];
 420                         context = fn;
 421                         fn = tmp;
 422                 }
 423
 424                 // Quick check to determine if target is callable, in the spec
 425                 // this throws a TypeError, but we will just return undefined.
 426                 if ( !jQuery.isFunction( fn ) ) {
 427                         return undefined;
 428                 }
 429
 430                 // Simulated bind
 431                 args = slice.call( arguments, 2 );
 432                 proxy = function() {
 433                         return fn.apply( context || this, args.concat( slice.call( arguments ) ) );
 434                 };
 435
 436                 // Set the guid of unique handler to the same of original handler, so it can be removed
 437                 proxy.guid = fn.guid = fn.guid || jQuery.guid++;
 438
 439                 return proxy;
 440         },
 441
 442         now: Date.now,
 443
 444         // jQuery.support is not used in Core but other projects attach their
 445         // properties to it so it needs to exist.
 446         support: support
 447 });
 448
 449 // Populate the class2type map
 450 jQuery.each("Boolean Number String Function Array Date RegExp Object Error".split(" "),
 451 function(i, name) {
 452         class2type[ "[object " + name + "]" ] = name.toLowerCase();
 453 });
 454
 455 function isArraylike( obj ) {
 456         var length = obj.length,
 457                 type = jQuery.type( obj );
 458
 459         if ( type === "function" || jQuery.isWindow( obj ) ) {
 460                 return false;
 461         }
 462
 463         if ( obj.nodeType === 1 && length ) {
 464                 return true;
 465         }
 466
 467         return type === "array" || length === 0 ||
 468                 typeof length === "number" && length > 0 && ( length - 1 ) in obj;
 469 }
 470
 471 return jQuery;
 472 });