src/manipulation.js

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