scratch – Diff between revs 58 and 125

Subversion Repositories:

?pathlinks?

Rev 58 – Details – Blame – Last modification – View Log

-define( [
+define([
 	"../core",
-	"../var/rnothtmlwhite",
+	"../var/rnotwhite",
-	"./var/acceptData"
+	"./accepts"
-], function( jQuery, rnothtmlwhite, acceptData ) {
+], function( jQuery, rnotwhite ) {
-"use strict";
+function Data() {
+	// Support: Android<4,
+	// Old WebKit does not have Object.preventExtensions/freeze method,
+	// return new empty object instead with no [[set]] accessor
+	Object.defineProperty( this.cache = {}, 0, {
+		get: function() {
+			return {};
+		}
+	});
 function Data() {
 	this.expando = jQuery.expando + Data.uid++;
+}
 Data.uid = 1;
+Data.accepts = jQuery.acceptData;
+Data.prototype = {
+	key: function( owner ) {
+		// We can accept data for non-element nodes in modern browsers,
+		// but we should not, see #8335.
+		// Always return the key for a frozen object.
-Data.uid = 1;
+		if ( !Data.accepts( owner ) ) {
-Data.prototype = {
+			return 0;
+		}
 	cache: function( owner ) {
+		var descriptor = {},
-		// Check if the owner object already has a cache
+			// Check if the owner object already has a cache key
-		var value = owner[ this.expando ];
+			unlock = owner[ this.expando ];
 		// If not, create one
-		if ( !value ) {
+		if ( !unlock ) {
-			value = {};
+			unlock = Data.uid++;
-			// We can accept data for non-element nodes in modern browsers,
+			// Secure it in a non-enumerable, non-writable property
-			// but we should not, see #8335.
+			try {
-			// Always return an empty object.
+				descriptor[ this.expando ] = { value: unlock };
-			if ( acceptData( owner ) ) {
-				// If it is a node unlikely to be stringify-ed or looped over
-				// use plain assignment
-				if ( owner.nodeType ) {
-					owner[ this.expando ] = value;
+				Object.defineProperties( owner, descriptor );
-				// Otherwise secure it in a non-enumerable property
-				// configurable must be true to allow the property to be
-				// deleted when data is removed
 				} else {
-					Object.defineProperty( owner, this.expando, {
+			// Support: Android<4
+			// Fallback to a less secure definition
+			} catch ( e ) {
+				descriptor[ this.expando ] = unlock;
+				jQuery.extend( owner, descriptor );
+			}
-						value: value,
+		}
 						configurable: true
-					} );
+		// Ensure the cache object
 		if ( !this.cache[ unlock ] ) {
+			this.cache[ unlock ] = {};
+		}
+		return unlock;
-			}
+	},
 	set: function( owner, data, value ) {
-		return value;
+		var prop,
-	},
+			// There may be an unlock assigned to this node,
-	set: function( owner, data, value ) {
+			// if there is no entry for this "owner", create one inline
-		var prop,
+			// and set the unlock as though an owner entry had always existed
-			cache = this.cache( owner );
+			unlock = this.key( owner ),
+			cache = this.cache[ unlock ];
+		// Handle: [ owner, key, value ] args
+		if ( typeof data === "string" ) {
-		// Handle: [ owner, key, value ] args
+			cache[ data ] = value;
-		// Always use camelCase key (gh-2257)
+		// Handle: [ owner, { properties } ] args
-		if ( typeof data === "string" ) {
+		} else {
-			cache[ jQuery.camelCase( data ) ] = value;
+			// Fresh assignments by object are shallow copied
 			if ( jQuery.isEmptyObject( cache ) ) {
-		// Handle: [ owner, { properties } ] args
+				jQuery.extend( this.cache[ unlock ], data );
-		} else {
+			// Otherwise, copy the properties one-by-one to the cache object
+			} else {
+				for ( prop in data ) {
+					cache[ prop ] = data[ prop ];
+				}
-			// Copy the properties one-by-one to the cache object
+			}
-			for ( prop in data ) {
+		}
-				cache[ jQuery.camelCase( prop ) ] = data[ prop ];
+		return cache;
 	},
 	get: function( owner, key ) {
-		return cache;
+		// Either a valid cache is found, or will be created.
-	},
+		// New caches will be created and the unlock returned,
-	get: function( owner, key ) {
+		// allowing direct access to the newly created
-		return key === undefined ?
+		// empty data object. A valid owner object must be provided.
-			this.cache( owner ) :
+		var cache = this.cache[ this.key( owner ) ];
 		//
 		//   1. The entire cache object
 		//   2. The data stored at the key
 		//
 		if ( key === undefined ||
-				( ( key && typeof key === "string" ) && value === undefined ) ) {
+				((key && typeof key === "string") && value === undefined) ) {
+			stored = this.get( owner, key );
+			return stored !== undefined ?
-			return this.get( owner, key );
+				stored : this.get( owner, jQuery.camelCase(key) );
 		}
-		// When the key is not a string, or both a key and value
+		// [*]When the key is not a string, or both a key and value
 		// are specified, set or extend (existing objects) with either:
 		//
 		//   1. An object of properties
 		// Since the "set" path can have two possible entry points
 		// return the expected data based on which path was taken[*]
 		return value !== undefined ? value : key;
 	},
 	remove: function( owner, key ) {
-		var i,
+		var i, name, camel,
+			unlock = this.key( owner ),
-			cache = owner[ this.expando ];
+			cache = this.cache[ unlock ];
-		if ( cache === undefined ) {
-			return;
-		}
+		if ( key === undefined ) {
+			this.cache[ unlock ] = {};
 		if ( key !== undefined ) {
 		} else {
-			// Support array or space separated string of keys
-			if ( jQuery.isArray( key ) ) {
+			// Support array or space separated string of keys
+			if ( jQuery.isArray( key ) ) {
+				// If "name" is an array of keys...
+				// When data is initially created, via ("key", "val") signature,
+				// keys will be converted to camelCase.
+				// Since there is no way to tell _how_ a key was added, remove
-				// If key is an array of keys...
+				// both plain key and camelCase key. #12786
-				// We always set camelCase keys, so remove that.
+				// This will only penalize the array argument path.
-				key = key.map( jQuery.camelCase );
+				name = key.concat( key.map( jQuery.camelCase ) );
+			} else {
+				camel = jQuery.camelCase( key );
+				// Try the string as a key before any manipulation
-			} else {
+				if ( key in cache ) {
-				key = jQuery.camelCase( key );
+					name = [ key, camel ];
+				} else {
-				// If a key with the spaces exists, use it.
+					// If a key with the spaces exists, use it.
-				// Otherwise, create an array by matching non-whitespace
+					// Otherwise, create an array by matching non-whitespace
-				key = key in cache ?
+					name = camel;
+					name = name in cache ?
-					[ key ] :
+						[ name ] : ( name.match( rnotwhite ) || [] );
-					( key.match( rnothtmlwhite ) || [] );
+				}
-			}
+			}
-			i = key.length;
-			while ( i-- ) {
-				delete cache[ key[ i ] ];
-			}
-		}
-		// Remove the expando if there's no more data
-		if ( key === undefined || jQuery.isEmptyObject( cache ) ) {
-			// Support: Chrome <=35 - 45
-			// Webkit & Blink performance suffers when deleting properties
-			// from DOM nodes, so set to undefined instead
-			// https://bugs.chromium.org/p/chromium/issues/detail?id=378607 (bug restricted)
-			if ( owner.nodeType ) {
-				owner[ this.expando ] = undefined;
+			i = name.length;
-			} else {
+			while ( i-- ) {
-				delete owner[ this.expando ];
+				delete cache[ name[ i ] ];
+			}
+		}
-		}
+	},
+	hasData: function( owner ) {
+		return !jQuery.isEmptyObject(
+			this.cache[ owner[ this.expando ] ] || {}
+		);
 	},
+	discard: function( owner ) {
-	hasData: function( owner ) {
+		if ( owner[ this.expando ] ) {
-		var cache = owner[ this.expando ];
+			delete this.cache[ owner[ this.expando ] ];
 		return cache !== undefined && !jQuery.isEmptyObject( cache );
 	}