src/manipulation.js

   1 define([
   2         "./core",
   3         "./var/concat",
   4         "./var/push",
   5         "./core/access",
   6         "./manipulation/var/rcheckableType",
   7         "./manipulation/var/rtagName",
   8         "./manipulation/var/rscriptType",
   9         "./manipulation/wrapMap",
  10         "./manipulation/getAll",
  11         "./manipulation/setGlobalEval",
  12         "./manipulation/buildFragment",
  13         "./manipulation/support",
  14
  15         "./data/var/dataPriv",
  16         "./data/var/dataUser",
  17
  18         "./core/init",
  19         "./data/accepts",
  20         "./traversing",
  21         "./selector",
  22         "./event"
  23 ], function( jQuery, concat, push, access,
  24         rcheckableType, rtagName, rscriptType,
  25         wrapMap, getAll, setGlobalEval, buildFragment, support,
  26         dataPriv, dataUser ) {
  27
  28 var
  29         rxhtmlTag = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\w:-]+)[^>]*)\/>/gi,
  30         rnoInnerhtml = /<(?:script|style|link)/i,
  31         // checked="checked" or checked
  32         rchecked = /checked\s*(?:[^=]|=\s*.checked.)/i,
  33         rscriptTypeMasked = /^true\/(.*)/,
  34         rcleanScript = /^\s*<!(?:\[CDATA\[|--)|(?:\]\]|--)>\s*$/g;
  35
  36 function manipulationTarget( elem, content ) {
  37         if ( jQuery.nodeName( elem, "table" ) &&
  38                 jQuery.nodeName( content.nodeType !== 11 ? content : content.firstChild, "tr" ) ) {
  39
  40                 return elem.getElementsByTagName( "tbody" )[ 0 ] || elem;
  41         }
  42
  43         return elem;
  44 }
  45
  46 // Replace/restore the type attribute of script elements for safe DOM manipulation
  47 function disableScript( elem ) {
  48         elem.type = (elem.getAttribute("type") !== null) + "/" + elem.type;
  49         return elem;
  50 }
  51 function restoreScript( elem ) {
  52         var match = rscriptTypeMasked.exec( elem.type );
  53
  54         if ( match ) {
  55                 elem.type = match[ 1 ];
  56         } else {
  57                 elem.removeAttribute("type");
  58         }
  59
  60         return elem;
  61 }
  62
  63 function cloneCopyEvent( src, dest ) {
  64         var i, l, type, pdataOld, pdataCur, udataOld, udataCur, events;
  65
  66         if ( dest.nodeType !== 1 ) {
  67                 return;
  68         }
  69
  70         // 1. Copy private data: events, handlers, etc.
  71         if ( dataPriv.hasData( src ) ) {
  72                 pdataOld = dataPriv.access( src );
  73                 pdataCur = dataPriv.set( dest, pdataOld );
  74                 events = pdataOld.events;
  75
  76                 if ( events ) {
  77                         delete pdataCur.handle;
  78                         pdataCur.events = {};
  79
  80                         for ( type in events ) {
  81                                 for ( i = 0, l = events[ type ].length; i < l; i++ ) {
  82                                         jQuery.event.add( dest, type, events[ type ][ i ] );
  83                                 }
  84                         }
  85                 }
  86         }
  87
  88         // 2. Copy user data
  89         if ( dataUser.hasData( src ) ) {
  90                 udataOld = dataUser.access( src );
  91                 udataCur = jQuery.extend( {}, udataOld );
  92
  93                 dataUser.set( dest, udataCur );
  94         }
  95 }
  96
  97 // Fix IE bugs, see support tests
  98 function fixInput( src, dest ) {
  99         var nodeName = dest.nodeName.toLowerCase();
 100
 101         // Fails to persist the checked state of a cloned checkbox or radio button.
 102         if ( nodeName === "input" && rcheckableType.test( src.type ) ) {
 103                 dest.checked = src.checked;
 104
 105         // Fails to return the selected option to the default selected state when cloning options
 106         } else if ( nodeName === "input" || nodeName === "textarea" ) {
 107                 dest.defaultValue = src.defaultValue;
 108         }
 109 }
 110
 111 jQuery.extend({
 112         htmlPrefilter: function( html ) {
 113                 return html.replace( rxhtmlTag, "<$1></$2>" );
 114         },
 115
 116         clone: function( elem, dataAndEvents, deepDataAndEvents ) {
 117                 var i, l, srcElements, destElements,
 118                         clone = elem.cloneNode( true ),
 119                         inPage = jQuery.contains( elem.ownerDocument, elem );
 120
 121                 // Fix IE cloning issues
 122                 if ( !support.noCloneChecked && ( elem.nodeType === 1 || elem.nodeType === 11 ) &&
 123                                 !jQuery.isXMLDoc( elem ) ) {
 124
 125                         // We eschew Sizzle here for performance reasons: http://jsperf.com/getall-vs-sizzle/2
 126                         destElements = getAll( clone );
 127                         srcElements = getAll( elem );
 128
 129                         for ( i = 0, l = srcElements.length; i < l; i++ ) {
 130                                 fixInput( srcElements[ i ], destElements[ i ] );
 131                         }
 132                 }
 133
 134                 // Copy the events from the original to the clone
 135                 if ( dataAndEvents ) {
 136                         if ( deepDataAndEvents ) {
 137                                 srcElements = srcElements || getAll( elem );
 138                                 destElements = destElements || getAll( clone );
 139
 140                                 for ( i = 0, l = srcElements.length; i < l; i++ ) {
 141                                         cloneCopyEvent( srcElements[ i ], destElements[ i ] );
 142                                 }
 143                         } else {
 144                                 cloneCopyEvent( elem, clone );
 145                         }
 146                 }
 147
 148                 // Preserve script evaluation history
 149                 destElements = getAll( clone, "script" );
 150                 if ( destElements.length > 0 ) {
 151                         setGlobalEval( destElements, !inPage && getAll( elem, "script" ) );
 152                 }
 153
 154                 // Return the cloned set
 155                 return clone;
 156         },
 157
 158         cleanData: function( elems ) {
 159                 var data, elem, type,
 160                         special = jQuery.event.special,
 161                         i = 0;
 162
 163                 for ( ; (elem = elems[ i ]) !== undefined; i++ ) {
 164                         if ( jQuery.acceptData( elem ) && (data = elem[ dataPriv.expando ])) {
 165                                 if ( data.events ) {
 166                                         for ( type in data.events ) {
 167                                                 if ( special[ type ] ) {
 168                                                         jQuery.event.remove( elem, type );
 169
 170                                                 // This is a shortcut to avoid jQuery.event.remove's overhead
 171                                                 } else {
 172                                                         jQuery.removeEvent( elem, type, data.handle );
 173                                                 }
 174                                         }
 175                                 }
 176                                 delete elem[ dataPriv.expando ];
 177                         }
 178                 }
 179         }
 180 });
 181
 182 jQuery.fn.extend({
 183         text: function( value ) {
 184                 return access( this, function( value ) {
 185                         return value === undefined ?
 186                                 jQuery.text( this ) :
 187                                 this.empty().each(function() {
 188                                         if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {
 189                                                 this.textContent = value;
 190                                         }
 191                                 });
 192                 }, null, value, arguments.length );
 193         },
 194
 195         append: function() {
 196                 return this.domManip( arguments, function( elem ) {
 197                         if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {
 198                                 var target = manipulationTarget( this, elem );
 199                                 target.appendChild( elem );
 200                         }
 201                 });
 202         },
 203
 204         prepend: function() {
 205                 return this.domManip( arguments, function( elem ) {
 206                         if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {
 207                                 var target = manipulationTarget( this, elem );
 208                                 target.insertBefore( elem, target.firstChild );
 209                         }
 210                 });
 211         },
 212
 213         before: function() {
 214                 return this.domManip( arguments, function( elem ) {
 215                         if ( this.parentNode ) {
 216                                 this.parentNode.insertBefore( elem, this );
 217                         }
 218                 });
 219         },
 220
 221         after: function() {
 222                 return this.domManip( arguments, function( elem ) {
 223                         if ( this.parentNode ) {
 224                                 this.parentNode.insertBefore( elem, this.nextSibling );
 225                         }
 226                 });
 227         },
 228
 229         remove: function( selector, keepData /* Internal Use Only */ ) {
 230                 var elem,
 231                         elems = selector ? jQuery.filter( selector, this ) : this,
 232                         i = 0;
 233
 234                 for ( ; (elem = elems[i]) != null; i++ ) {
 235                         if ( !keepData && elem.nodeType === 1 ) {
 236                                 jQuery.cleanData( getAll( elem ) );
 237                         }
 238
 239                         if ( elem.parentNode ) {
 240                                 if ( keepData && jQuery.contains( elem.ownerDocument, elem ) ) {
 241                                         setGlobalEval( getAll( elem, "script" ) );
 242                                 }
 243                                 elem.parentNode.removeChild( elem );
 244                         }
 245                 }
 246
 247                 return this;
 248         },
 249
 250         empty: function() {
 251                 var elem,
 252                         i = 0;
 253
 254                 for ( ; (elem = this[i]) != null; i++ ) {
 255                         if ( elem.nodeType === 1 ) {
 256
 257                                 // Prevent memory leaks
 258                                 jQuery.cleanData( getAll( elem, false ) );
 259
 260                                 // Remove any remaining nodes
 261                                 elem.textContent = "";
 262                         }
 263                 }
 264
 265                 return this;
 266         },
 267
 268         clone: function( dataAndEvents, deepDataAndEvents ) {
 269                 dataAndEvents = dataAndEvents == null ? false : dataAndEvents;
 270                 deepDataAndEvents = deepDataAndEvents == null ? dataAndEvents : deepDataAndEvents;
 271
 272                 return this.map(function() {
 273                         return jQuery.clone( this, dataAndEvents, deepDataAndEvents );
 274                 });
 275         },
 276
 277         html: function( value ) {
 278                 return access( this, function( value ) {
 279                         var elem = this[ 0 ] || {},
 280                                 i = 0,
 281                                 l = this.length;
 282
 283                         if ( value === undefined && elem.nodeType === 1 ) {
 284                                 return elem.innerHTML;
 285                         }
 286
 287                         // See if we can take a shortcut and just use innerHTML
 288                         if ( typeof value === "string" && !rnoInnerhtml.test( value ) &&
 289                                 !wrapMap[ ( rtagName.exec( value ) || [ "", "" ] )[ 1 ].toLowerCase() ] ) {
 290
 291                                 value = jQuery.htmlPrefilter( value );
 292
 293                                 try {
 294                                         for ( ; i < l; i++ ) {
 295                                                 elem = this[ i ] || {};
 296
 297                                                 // Remove element nodes and prevent memory leaks
 298                                                 if ( elem.nodeType === 1 ) {
 299                                                         jQuery.cleanData( getAll( elem, false ) );
 300                                                         elem.innerHTML = value;
 301                                                 }
 302                                         }
 303
 304                                         elem = 0;
 305
 306                                 // If using innerHTML throws an exception, use the fallback method
 307                                 } catch ( e ) {}
 308                         }
 309
 310                         if ( elem ) {
 311                                 this.empty().append( value );
 312                         }
 313                 }, null, value, arguments.length );
 314         },
 315
 316         replaceWith: function() {
 317                 var ignored = [];
 318
 319                 // Make the changes, replacing each non-ignored context element with the new content
 320                 return this.domManip( arguments, function( elem ) {
 321                         var parent = this.parentNode;
 322
 323                         if ( jQuery.inArray( this, ignored ) < 0 ) {
 324                                 jQuery.cleanData( getAll( this ) );
 325                                 if ( parent ) {
 326                                         parent.replaceChild( elem, this );
 327                                 }
 328                         }
 329
 330                 // Force callback invocation
 331                 }, ignored );
 332         },
 333
 334         detach: function( selector ) {
 335                 return this.remove( selector, true );
 336         },
 337
 338         domManip: function( args, callback, ignored ) {
 339
 340                 // Flatten any nested arrays
 341                 args = concat.apply( [], args );
 342
 343                 var fragment, first, scripts, hasScripts, node, doc,
 344                         i = 0,
 345                         l = this.length,
 346                         set = this,
 347                         iNoClone = l - 1,
 348                         value = args[ 0 ],
 349                         isFunction = jQuery.isFunction( value );
 350
 351                 // We can't cloneNode fragments that contain checked, in WebKit
 352                 if ( isFunction ||
 353                                 ( l > 1 && typeof value === "string" &&
 354                                         !support.checkClone && rchecked.test( value ) ) ) {
 355                         return this.each(function( index ) {
 356                                 var self = set.eq( index );
 357                                 if ( isFunction ) {
 358                                         args[ 0 ] = value.call( this, index, self.html() );
 359                                 }
 360                                 self.domManip( args, callback, ignored );
 361                         });
 362                 }
 363
 364                 if ( l ) {
 365                         fragment = buildFragment( args, this[ 0 ].ownerDocument, false, this, ignored );
 366                         first = fragment.firstChild;
 367
 368                         if ( fragment.childNodes.length === 1 ) {
 369                                 fragment = first;
 370                         }
 371
 372                         // Require either new content or an interest in ignored elements to invoke the callback
 373                         if ( first || ignored ) {
 374                                 scripts = jQuery.map( getAll( fragment, "script" ), disableScript );
 375                                 hasScripts = scripts.length;
 376
 377                                 // Use the original fragment for the last item
 378                                 // instead of the first because it can end up
 379                                 // being emptied incorrectly in certain situations (#8070).
 380                                 for ( ; i < l; i++ ) {
 381                                         node = fragment;
 382
 383                                         if ( i !== iNoClone ) {
 384                                                 node = jQuery.clone( node, true, true );
 385
 386                                                 // Keep references to cloned scripts for later restoration
 387                                                 if ( hasScripts ) {
 388                                                         // Support: Android<4.1, PhantomJS<2
 389                                                         // push.apply(_, arraylike) throws on ancient WebKit
 390                                                         jQuery.merge( scripts, getAll( node, "script" ) );
 391                                                 }
 392                                         }
 393
 394                                         callback.call( this[ i ], node, i );
 395                                 }
 396
 397                                 if ( hasScripts ) {
 398                                         doc = scripts[ scripts.length - 1 ].ownerDocument;
 399
 400                                         // Reenable scripts
 401                                         jQuery.map( scripts, restoreScript );
 402
 403                                         // Evaluate executable scripts on first document insertion
 404                                         for ( i = 0; i < hasScripts; i++ ) {
 405                                                 node = scripts[ i ];
 406                                                 if ( rscriptType.test( node.type || "" ) &&
 407                                                         !dataPriv.access( node, "globalEval" ) &&
 408                                                         jQuery.contains( doc, node ) ) {
 409
 410                                                         if ( node.src ) {
 411                                                                 // Optional AJAX dependency, but won't run scripts if not present
 412                                                                 if ( jQuery._evalUrl ) {
 413                                                                         jQuery._evalUrl( node.src );
 414                                                                 }
 415                                                         } else {
 416                                                                 jQuery.globalEval( node.textContent.replace( rcleanScript, "" ) );
 417                                                         }
 418                                                 }
 419                                         }
 420                                 }
 421                         }
 422                 }
 423
 424                 return this;
 425         }
 426 });
 427
 428 jQuery.each({
 429         appendTo: "append",
 430         prependTo: "prepend",
 431         insertBefore: "before",
 432         insertAfter: "after",
 433         replaceAll: "replaceWith"
 434 }, function( name, original ) {
 435         jQuery.fn[ name ] = function( selector ) {
 436                 var elems,
 437                         ret = [],
 438                         insert = jQuery( selector ),
 439                         last = insert.length - 1,
 440                         i = 0;
 441
 442                 for ( ; i <= last; i++ ) {
 443                         elems = i === last ? this : this.clone( true );
 444                         jQuery( insert[ i ] )[ original ]( elems );
 445
 446                         // Support: Android<4.1, PhantomJS<2
 447                         // .get() because push.apply(_, arraylike) throws on ancient WebKit
 448                         push.apply( ret, elems.get() );
 449                 }
 450
 451                 return this.pushStack( ret );
 452         };
 453 });
 454
 455 return jQuery;
 456 });