src/data.js

   1 var rbrace = /(?:\{[\s\S]*\}|\[[\s\S]*\])$/,
   2         rmultiDash = /([A-Z])/g;
   3
   4 function internalData( elem, name, data, pvt ) {
   5         if ( !jQuery.acceptData( elem ) ) {
   6                 return;
   7         }
   8
   9         var thisCache, ret,
  10                 internalKey = jQuery.expando,
  11                 getByName = typeof name === "string",
  12
  13                 // We have to handle DOM nodes and JS objects differently because IE6-7
  14                 // can't GC object references properly across the DOM-JS boundary
  15                 isNode = elem.nodeType,
  16
  17                 // Only DOM nodes need the global jQuery cache; JS object data is
  18                 // attached directly to the object so GC can occur automatically
  19                 cache = isNode ? jQuery.cache : elem,
  20
  21                 // Only defining an ID for JS objects if its cache already exists allows
  22                 // the code to shortcut on the same path as a DOM node with no cache
  23                 id = isNode ? elem[ internalKey ] : elem[ internalKey ] && internalKey;
  24
  25         // Avoid doing any more work than we need to when trying to get data on an
  26         // object that has no data at all
  27         if ( (!id || !cache[id] || (!pvt && !cache[id].data)) && getByName && data === undefined ) {
  28                 return;
  29         }
  30
  31         if ( !id ) {
  32                 // Only DOM nodes need a new unique ID for each element since their data
  33                 // ends up in the global cache
  34                 if ( isNode ) {
  35                         elem[ internalKey ] = id = core_deletedIds.pop() || jQuery.guid++;
  36                 } else {
  37                         id = internalKey;
  38                 }
  39         }
  40
  41         if ( !cache[ id ] ) {
  42                 cache[ id ] = {};
  43
  44                 // Avoids exposing jQuery metadata on plain JS objects when the object
  45                 // is serialized using JSON.stringify
  46                 if ( !isNode ) {
  47                         cache[ id ].toJSON = jQuery.noop;
  48                 }
  49         }
  50
  51         // An object can be passed to jQuery.data instead of a key/value pair; this gets
  52         // shallow copied over onto the existing cache
  53         if ( typeof name === "object" || typeof name === "function" ) {
  54                 if ( pvt ) {
  55                         cache[ id ] = jQuery.extend( cache[ id ], name );
  56                 } else {
  57                         cache[ id ].data = jQuery.extend( cache[ id ].data, name );
  58                 }
  59         }
  60
  61         thisCache = cache[ id ];
  62
  63         // jQuery data() is stored in a separate object inside the object's internal data
  64         // cache in order to avoid key collisions between internal data and user-defined
  65         // data.
  66         if ( !pvt ) {
  67                 if ( !thisCache.data ) {
  68                         thisCache.data = {};
  69                 }
  70
  71                 thisCache = thisCache.data;
  72         }
  73
  74         if ( data !== undefined ) {
  75                 thisCache[ jQuery.camelCase( name ) ] = data;
  76         }
  77
  78         // Check for both converted-to-camel and non-converted data property names
  79         // If a data property was specified
  80         if ( getByName ) {
  81
  82                 // First Try to find as-is property data
  83                 ret = thisCache[ name ];
  84
  85                 // Test for null|undefined property data
  86                 if ( ret == null ) {
  87
  88                         // Try to find the camelCased property
  89                         ret = thisCache[ jQuery.camelCase( name ) ];
  90                 }
  91         } else {
  92                 ret = thisCache;
  93         }
  94
  95         return ret;
  96 }
  97
  98 function internalRemoveData( elem, name, pvt ) {
  99         if ( !jQuery.acceptData( elem ) ) {
 100                 return;
 101         }
 102
 103         var thisCache, i, l,
 104
 105                 isNode = elem.nodeType,
 106
 107                 // See jQuery.data for more information
 108                 cache = isNode ? jQuery.cache : elem,
 109                 id = isNode ? elem[ jQuery.expando ] : jQuery.expando;
 110
 111         // If there is already no cache entry for this object, there is no
 112         // purpose in continuing
 113         if ( !cache[ id ] ) {
 114                 return;
 115         }
 116
 117         if ( name ) {
 118
 119                 thisCache = pvt ? cache[ id ] : cache[ id ].data;
 120
 121                 if ( thisCache ) {
 122
 123                         // Support array or space separated string names for data keys
 124                         if ( !jQuery.isArray( name ) ) {
 125
 126                                 // try the string as a key before any manipulation
 127                                 if ( name in thisCache ) {
 128                                         name = [ name ];
 129                                 } else {
 130
 131                                         // split the camel cased version by spaces unless a key with the spaces exists
 132                                         name = jQuery.camelCase( name );
 133                                         if ( name in thisCache ) {
 134                                                 name = [ name ];
 135                                         } else {
 136                                                 name = name.split(" ");
 137                                         }
 138                                 }
 139                         } else {
 140                                 // If "name" is an array of keys...
 141                                 // When data is initially created, via ("key", "val") signature,
 142                                 // keys will be converted to camelCase.
 143                                 // Since there is no way to tell _how_ a key was added, remove
 144                                 // both plain key and camelCase key. #12786
 145                                 // This will only penalize the array argument path.
 146                                 name = name.concat( jQuery.map( name, jQuery.camelCase ) );
 147                         }
 148
 149                         for ( i = 0, l = name.length; i < l; i++ ) {
 150                                 delete thisCache[ name[i] ];
 151                         }
 152
 153                         // If there is no data left in the cache, we want to continue
 154                         // and let the cache object itself get destroyed
 155                         if ( !( pvt ? isEmptyDataObject : jQuery.isEmptyObject )( thisCache ) ) {
 156                                 return;
 157                         }
 158                 }
 159         }
 160
 161         // See jQuery.data for more information
 162         if ( !pvt ) {
 163                 delete cache[ id ].data;
 164
 165                 // Don't destroy the parent cache unless the internal data object
 166                 // had been the only thing left in it
 167                 if ( !isEmptyDataObject( cache[ id ] ) ) {
 168                         return;
 169                 }
 170         }
 171
 172         // Destroy the cache
 173         if ( isNode ) {
 174                 jQuery.cleanData( [ elem ], true );
 175
 176         // Use delete when supported for expandos or `cache` is not a window per isWindow (#10080)
 177         } else if ( jQuery.support.deleteExpando || cache != cache.window ) {
 178                 delete cache[ id ];
 179
 180         // When all else fails, null
 181         } else {
 182                 cache[ id ] = null;
 183         }
 184 }
 185
 186 jQuery.extend({
 187         cache: {},
 188
 189         // Unique for each copy of jQuery on the page
 190         // Non-digits removed to match rinlinejQuery
 191         expando: "jQuery" + ( core_version + Math.random() ).replace( /\D/g, "" ),
 192
 193         // The following elements throw uncatchable exceptions if you
 194         // attempt to add expando properties to them.
 195         noData: {
 196                 "embed": true,
 197                 // Ban all objects except for Flash (which handle expandos)
 198                 "object": "clsid:D27CDB6E-AE6D-11cf-96B8-444553540000",
 199                 "applet": true
 200         },
 201
 202         hasData: function( elem ) {
 203                 elem = elem.nodeType ? jQuery.cache[ elem[jQuery.expando] ] : elem[ jQuery.expando ];
 204                 return !!elem && !isEmptyDataObject( elem );
 205         },
 206
 207         data: function( elem, name, data ) {
 208                 return internalData( elem, name, data );
 209         },
 210
 211         removeData: function( elem, name ) {
 212                 return internalRemoveData( elem, name );
 213         },
 214
 215         // For internal use only.
 216         _data: function( elem, name, data ) {
 217                 return internalData( elem, name, data, true );
 218         },
 219
 220         _removeData: function( elem, name ) {
 221                 return internalRemoveData( elem, name, true );
 222         },
 223
 224         // A method for determining if a DOM node can handle the data expando
 225         acceptData: function( elem ) {
 226                 // Do not set data on non-element because it will not be cleared (#8335).
 227                 if ( elem.nodeType && elem.nodeType !== 1 && elem.nodeType !== 9 ) {
 228                         return false;
 229                 }
 230
 231                 var noData = elem.nodeName && jQuery.noData[ elem.nodeName.toLowerCase() ];
 232
 233                 // nodes accept data unless otherwise specified; rejection can be conditional
 234                 return !noData || noData !== true && elem.getAttribute("classid") === noData;
 235         }
 236 });
 237
 238 jQuery.fn.extend({
 239         data: function( key, value ) {
 240                 var attrs, name,
 241                         elem = this[0],
 242                         i = 0,
 243                         data = null;
 244
 245                 // Gets all values
 246                 if ( key === undefined ) {
 247                         if ( this.length ) {
 248                                 data = jQuery.data( elem );
 249
 250                                 if ( elem.nodeType === 1 && !jQuery._data( elem, "parsedAttrs" ) ) {
 251                                         attrs = elem.attributes;
 252                                         for ( ; i < attrs.length; i++ ) {
 253                                                 name = attrs[i].name;
 254
 255                                                 if ( !name.indexOf( "data-" ) ) {
 256                                                         name = jQuery.camelCase( name.slice(5) );
 257
 258                                                         dataAttr( elem, name, data[ name ] );
 259                                                 }
 260                                         }
 261                                         jQuery._data( elem, "parsedAttrs", true );
 262                                 }
 263                         }
 264
 265                         return data;
 266                 }
 267
 268                 // Sets multiple values
 269                 if ( typeof key === "object" ) {
 270                         return this.each(function() {
 271                                 jQuery.data( this, key );
 272                         });
 273                 }
 274
 275                 return jQuery.access( this, function( value ) {
 276
 277                         if ( value === undefined ) {
 278                                 // Try to fetch any internally stored data first
 279                                 return elem ? dataAttr( elem, key, jQuery.data( elem, key ) ) : null;
 280                         }
 281
 282                         this.each(function() {
 283                                 jQuery.data( this, key, value );
 284                         });
 285                 }, null, value, arguments.length > 1, null, true );
 286         },
 287
 288         removeData: function( key ) {
 289                 return this.each(function() {
 290                         jQuery.removeData( this, key );
 291                 });
 292         }
 293 });
 294
 295 function dataAttr( elem, key, data ) {
 296         // If nothing was found internally, try to fetch any
 297         // data from the HTML5 data-* attribute
 298         if ( data === undefined && elem.nodeType === 1 ) {
 299
 300                 var name = "data-" + key.replace( rmultiDash, "-$1" ).toLowerCase();
 301
 302                 data = elem.getAttribute( name );
 303
 304                 if ( typeof data === "string" ) {
 305                         try {
 306                                 data = data === "true" ? true :
 307                                         data === "false" ? false :
 308                                         data === "null" ? null :
 309                                         // Only convert to a number if it doesn't change the string
 310                                         +data + "" === data ? +data :
 311                                         rbrace.test( data ) ? jQuery.parseJSON( data ) :
 312                                                 data;
 313                         } catch( e ) {}
 314
 315                         // Make sure we set the data so it isn't changed later
 316                         jQuery.data( elem, key, data );
 317
 318                 } else {
 319                         data = undefined;
 320                 }
 321         }
 322
 323         return data;
 324 }
 325
 326 // checks a cache object for emptiness
 327 function isEmptyDataObject( obj ) {
 328         var name;
 329         for ( name in obj ) {
 330
 331                 // if the public data object is empty, the private is still empty
 332                 if ( name === "data" && jQuery.isEmptyObject( obj[name] ) ) {
 333                         continue;
 334                 }
 335                 if ( name !== "toJSON" ) {
 336                         return false;
 337                 }
 338         }
 339
 340         return true;
 341 }