xonecas.io
286
Sf

simple-flask-coffee-sass-boilerplate / files

simple-flask-coffee-sass-boilerplate / bower_components / jquery / src / data / Data.js

4.8 KB
1define([
2	"../core",
3	"../var/rnotwhite",
4	"./accepts"
5], function( jQuery, rnotwhite ) {
6
7function Data() {
8	// Support: Android < 4,
9	// Old WebKit does not have Object.preventExtensions/freeze method,
10	// return new empty object instead with no [[set]] accessor
11	Object.defineProperty( this.cache = {}, 0, {
12		get: function() {
13			return {};
14		}
15	});
16
17	this.expando = jQuery.expando + Math.random();
18}
19
20Data.uid = 1;
21Data.accepts = jQuery.acceptData;
22
23Data.prototype = {
24	key: function( owner ) {
25		// We can accept data for non-element nodes in modern browsers,
26		// but we should not, see #8335.
27		// Always return the key for a frozen object.
28		if ( !Data.accepts( owner ) ) {
29			return 0;
30		}
31
32		var descriptor = {},
33			// Check if the owner object already has a cache key
34			unlock = owner[ this.expando ];
35
36		// If not, create one
37		if ( !unlock ) {
38			unlock = Data.uid++;
39
40			// Secure it in a non-enumerable, non-writable property
41			try {
42				descriptor[ this.expando ] = { value: unlock };
43				Object.defineProperties( owner, descriptor );
44
45			// Support: Android < 4
46			// Fallback to a less secure definition
47			} catch ( e ) {
48				descriptor[ this.expando ] = unlock;
49				jQuery.extend( owner, descriptor );
50			}
51		}
52
53		// Ensure the cache object
54		if ( !this.cache[ unlock ] ) {
55			this.cache[ unlock ] = {};
56		}
57
58		return unlock;
59	},
60	set: function( owner, data, value ) {
61		var prop,
62			// There may be an unlock assigned to this node,
63			// if there is no entry for this "owner", create one inline
64			// and set the unlock as though an owner entry had always existed
65			unlock = this.key( owner ),
66			cache = this.cache[ unlock ];
67
68		// Handle: [ owner, key, value ] args
69		if ( typeof data === "string" ) {
70			cache[ data ] = value;
71
72		// Handle: [ owner, { properties } ] args
73		} else {
74			// Fresh assignments by object are shallow copied
75			if ( jQuery.isEmptyObject( cache ) ) {
76				jQuery.extend( this.cache[ unlock ], data );
77			// Otherwise, copy the properties one-by-one to the cache object
78			} else {
79				for ( prop in data ) {
80					cache[ prop ] = data[ prop ];
81				}
82			}
83		}
84		return cache;
85	},
86	get: function( owner, key ) {
87		// Either a valid cache is found, or will be created.
88		// New caches will be created and the unlock returned,
89		// allowing direct access to the newly created
90		// empty data object. A valid owner object must be provided.
91		var cache = this.cache[ this.key( owner ) ];
92
93		return key === undefined ?
94			cache : cache[ key ];
95	},
96	access: function( owner, key, value ) {
97		var stored;
98		// In cases where either:
99		//
100		//   1. No key was specified
101		//   2. A string key was specified, but no value provided
102		//
103		// Take the "read" path and allow the get method to determine
104		// which value to return, respectively either:
105		//
106		//   1. The entire cache object
107		//   2. The data stored at the key
108		//
109		if ( key === undefined ||
110				((key && typeof key === "string") && value === undefined) ) {
111
112			stored = this.get( owner, key );
113
114			return stored !== undefined ?
115				stored : this.get( owner, jQuery.camelCase(key) );
116		}
117
118		// [*]When the key is not a string, or both a key and value
119		// are specified, set or extend (existing objects) with either:
120		//
121		//   1. An object of properties
122		//   2. A key and value
123		//
124		this.set( owner, key, value );
125
126		// Since the "set" path can have two possible entry points
127		// return the expected data based on which path was taken[*]
128		return value !== undefined ? value : key;
129	},
130	remove: function( owner, key ) {
131		var i, name, camel,
132			unlock = this.key( owner ),
133			cache = this.cache[ unlock ];
134
135		if ( key === undefined ) {
136			this.cache[ unlock ] = {};
137
138		} else {
139			// Support array or space separated string of keys
140			if ( jQuery.isArray( key ) ) {
141				// If "name" is an array of keys...
142				// When data is initially created, via ("key", "val") signature,
143				// keys will be converted to camelCase.
144				// Since there is no way to tell _how_ a key was added, remove
145				// both plain key and camelCase key. #12786
146				// This will only penalize the array argument path.
147				name = key.concat( key.map( jQuery.camelCase ) );
148			} else {
149				camel = jQuery.camelCase( key );
150				// Try the string as a key before any manipulation
151				if ( key in cache ) {
152					name = [ key, camel ];
153				} else {
154					// If a key with the spaces exists, use it.
155					// Otherwise, create an array by matching non-whitespace
156					name = camel;
157					name = name in cache ?
158						[ name ] : ( name.match( rnotwhite ) || [] );
159				}
160			}
161
162			i = name.length;
163			while ( i-- ) {
164				delete cache[ name[ i ] ];
165			}
166		}
167	},
168	hasData: function( owner ) {
169		return !jQuery.isEmptyObject(
170			this.cache[ owner[ this.expando ] ] || {}
171		);
172	},
173	discard: function( owner ) {
174		if ( owner[ this.expando ] ) {
175			delete this.cache[ owner[ this.expando ] ];
176		}
177	}
178};
179
180return Data;
181});