Diffstat (limited to 'frontend/gamma/js/Zepto/ajax.js') (more/less context) (ignore whitespace changes)
-rw-r--r-- | frontend/gamma/js/Zepto/ajax.js | 285 |
1 files changed, 0 insertions, 285 deletions
diff --git a/frontend/gamma/js/Zepto/ajax.js b/frontend/gamma/js/Zepto/ajax.js deleted file mode 100644 index f4da150..0000000 --- a/frontend/gamma/js/Zepto/ajax.js +++ b/dev/null | |||
@@ -1,285 +0,0 @@ | |||
1 | // Zepto.js | ||
2 | // (c) 2010-2012 Thomas Fuchs | ||
3 | // Zepto.js may be freely distributed under the MIT license. | ||
4 | |||
5 | ;(function($){ | ||
6 | var jsonpID = 0, | ||
7 | isObject = $.isObject, | ||
8 | document = window.document, | ||
9 | key, | ||
10 | name, | ||
11 | rscript = /<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi, | ||
12 | scriptTypeRE = /^(?:text|application)\/javascript/i, | ||
13 | xmlTypeRE = /^(?:text|application)\/xml/i, | ||
14 | jsonType = 'application/json', | ||
15 | htmlType = 'text/html', | ||
16 | blankRE = /^\s*$/ | ||
17 | |||
18 | // trigger a custom event and return false if it was cancelled | ||
19 | function triggerAndReturn(context, eventName, data) { | ||
20 | var event = $.Event(eventName) | ||
21 | $(context).trigger(event, data) | ||
22 | return !event.defaultPrevented | ||
23 | } | ||
24 | |||
25 | // trigger an Ajax "global" event | ||
26 | function triggerGlobal(settings, context, eventName, data) { | ||
27 | if (settings.global) return triggerAndReturn(context || document, eventName, data) | ||
28 | } | ||
29 | |||
30 | // Number of active Ajax requests | ||
31 | $.active = 0 | ||
32 | |||
33 | function ajaxStart(settings) { | ||
34 | if (settings.global && $.active++ === 0) triggerGlobal(settings, null, 'ajaxStart') | ||
35 | } | ||
36 | function ajaxStop(settings) { | ||
37 | if (settings.global && !(--$.active)) triggerGlobal(settings, null, 'ajaxStop') | ||
38 | } | ||
39 | |||
40 | // triggers an extra global event "ajaxBeforeSend" that's like "ajaxSend" but cancelable | ||
41 | function ajaxBeforeSend(xhr, settings) { | ||
42 | var context = settings.context | ||
43 | if (settings.beforeSend.call(context, xhr, settings) === false || | ||
44 | triggerGlobal(settings, context, 'ajaxBeforeSend', [xhr, settings]) === false) | ||
45 | return false | ||
46 | |||
47 | triggerGlobal(settings, context, 'ajaxSend', [xhr, settings]) | ||
48 | } | ||
49 | function ajaxSuccess(data, xhr, settings) { | ||
50 | var context = settings.context, status = 'success' | ||
51 | settings.success.call(context, data, status, xhr) | ||
52 | triggerGlobal(settings, context, 'ajaxSuccess', [xhr, settings, data]) | ||
53 | ajaxComplete(status, xhr, settings) | ||
54 | } | ||
55 | // type: "timeout", "error", "abort", "parsererror" | ||
56 | function ajaxError(error, type, xhr, settings) { | ||
57 | var context = settings.context | ||
58 | settings.error.call(context, xhr, type, error) | ||
59 | triggerGlobal(settings, context, 'ajaxError', [xhr, settings, error]) | ||
60 | ajaxComplete(type, xhr, settings) | ||
61 | } | ||
62 | // status: "success", "notmodified", "error", "timeout", "abort", "parsererror" | ||
63 | function ajaxComplete(status, xhr, settings) { | ||
64 | var context = settings.context | ||
65 | settings.complete.call(context, xhr, status) | ||
66 | triggerGlobal(settings, context, 'ajaxComplete', [xhr, settings]) | ||
67 | ajaxStop(settings) | ||
68 | } | ||
69 | |||
70 | // Empty function, used as default callback | ||
71 | function empty() {} | ||
72 | |||
73 | $.ajaxJSONP = function(options){ | ||
74 | if (!('type' in options)) return $.ajax(options) | ||
75 | |||
76 | var callbackName = 'jsonp' + (++jsonpID), | ||
77 | script = document.createElement('script'), | ||
78 | abort = function(){ | ||
79 | $(script).remove() | ||
80 | if (callbackName in window) window[callbackName] = empty | ||
81 | ajaxComplete('abort', xhr, options) | ||
82 | }, | ||
83 | xhr = { abort: abort }, abortTimeout | ||
84 | |||
85 | if (options.error) script.onerror = function() { | ||
86 | xhr.abort() | ||
87 | options.error() | ||
88 | } | ||
89 | |||
90 | window[callbackName] = function(data){ | ||
91 | clearTimeout(abortTimeout) | ||
92 | $(script).remove() | ||
93 | delete window[callbackName] | ||
94 | ajaxSuccess(data, xhr, options) | ||
95 | } | ||
96 | |||
97 | serializeData(options) | ||
98 | script.src = options.url.replace(/=\?/, '=' + callbackName) | ||
99 | $('head').append(script) | ||
100 | |||
101 | if (options.timeout > 0) abortTimeout = setTimeout(function(){ | ||
102 | xhr.abort() | ||
103 | ajaxComplete('timeout', xhr, options) | ||
104 | }, options.timeout) | ||
105 | |||
106 | return xhr | ||
107 | } | ||
108 | |||
109 | $.ajaxSettings = { | ||
110 | // Default type of request | ||
111 | type: 'GET', | ||
112 | // Callback that is executed before request | ||
113 | beforeSend: empty, | ||
114 | // Callback that is executed if the request succeeds | ||
115 | success: empty, | ||
116 | // Callback that is executed the the server drops error | ||
117 | error: empty, | ||
118 | // Callback that is executed on request complete (both: error and success) | ||
119 | complete: empty, | ||
120 | // The context for the callbacks | ||
121 | context: null, | ||
122 | // Whether to trigger "global" Ajax events | ||
123 | global: true, | ||
124 | // Transport | ||
125 | xhr: function () { | ||
126 | return new window.XMLHttpRequest() | ||
127 | }, | ||
128 | // MIME types mapping | ||
129 | accepts: { | ||
130 | script: 'text/javascript, application/javascript', | ||
131 | json: jsonType, | ||
132 | xml: 'application/xml, text/xml', | ||
133 | html: htmlType, | ||
134 | text: 'text/plain' | ||
135 | }, | ||
136 | // Whether the request is to another domain | ||
137 | crossDomain: false, | ||
138 | // Default timeout | ||
139 | timeout: 0, | ||
140 | // Whether data should be serialized to string | ||
141 | processData: true | ||
142 | } | ||
143 | |||
144 | function mimeToDataType(mime) { | ||
145 | return mime && ( mime == htmlType ? 'html' : | ||
146 | mime == jsonType ? 'json' : | ||
147 | scriptTypeRE.test(mime) ? 'script' : | ||
148 | xmlTypeRE.test(mime) && 'xml' ) || 'text' | ||
149 | } | ||
150 | |||
151 | function appendQuery(url, query) { | ||
152 | return (url + '&' + query).replace(/[&?]{1,2}/, '?') | ||
153 | } | ||
154 | |||
155 | // serialize payload and append it to the URL for GET requests | ||
156 | function serializeData(options) { | ||
157 | if (options.processData && isObject(options.data)) | ||
158 | options.data = $.param(options.data, options.traditional) | ||
159 | if (options.data && (!options.type || options.type.toUpperCase() == 'GET')) | ||
160 | options.url = appendQuery(options.url, options.data) | ||
161 | } | ||
162 | |||
163 | $.ajax = function(options){ | ||
164 | var settings = $.extend({}, options || {}) | ||
165 | for (key in $.ajaxSettings) if (settings[key] === undefined) settings[key] = $.ajaxSettings[key] | ||
166 | |||
167 | ajaxStart(settings) | ||
168 | |||
169 | if (!settings.crossDomain) settings.crossDomain = /^([\w-]+:)?\/\/([^\/]+)/.test(settings.url) && | ||
170 | RegExp.$2 != window.location.host | ||
171 | |||
172 | var dataType = settings.dataType, hasPlaceholder = /=\?/.test(settings.url) | ||
173 | if (dataType == 'jsonp' || hasPlaceholder) { | ||
174 | if (!hasPlaceholder) settings.url = appendQuery(settings.url, 'callback=?') | ||
175 | return $.ajaxJSONP(settings) | ||
176 | } | ||
177 | |||
178 | if (!settings.url) settings.url = window.location.toString() | ||
179 | serializeData(settings) | ||
180 | |||
181 | var mime = settings.accepts[dataType], | ||
182 | baseHeaders = { }, | ||
183 | protocol = /^([\w-]+:)\/\//.test(settings.url) ? RegExp.$1 : window.location.protocol, | ||
184 | xhr = $.ajaxSettings.xhr(), abortTimeout | ||
185 | |||
186 | if (!settings.crossDomain) baseHeaders['X-Requested-With'] = 'XMLHttpRequest' | ||
187 | if (mime) { | ||
188 | baseHeaders['Accept'] = mime | ||
189 | if (mime.indexOf(',') > -1) mime = mime.split(',', 2)[0] | ||
190 | xhr.overrideMimeType && xhr.overrideMimeType(mime) | ||
191 | } | ||
192 | if (settings.contentType || (settings.contentType !== false && settings.data && settings.type.toUpperCase() != 'GET')) | ||
193 | baseHeaders['Content-Type'] = (settings.contentType || 'application/x-www-form-urlencoded') | ||
194 | settings.headers = $.extend(baseHeaders, settings.headers || {}) | ||
195 | |||
196 | xhr.onreadystatechange = function(){ | ||
197 | if (xhr.readyState == 4) { | ||
198 | xhr.onreadystatechange = empty; | ||
199 | clearTimeout(abortTimeout) | ||
200 | var result, error = false | ||
201 | if ((xhr.status >= 200 && xhr.status < 300) || xhr.status == 304 || (xhr.status == 0 && protocol == 'file:')) { | ||
202 | dataType = dataType || mimeToDataType(xhr.getResponseHeader('content-type')) | ||
203 | result = xhr.responseText | ||
204 | |||
205 | try { | ||
206 | if (dataType == 'script') (1,eval)(result) | ||
207 | else if (dataType == 'xml') result = xhr.responseXML | ||
208 | else if (dataType == 'json') result = blankRE.test(result) ? null : $.parseJSON(result) | ||
209 | } catch (e) { error = e } | ||
210 | |||
211 | if (error) ajaxError(error, 'parsererror', xhr, settings) | ||
212 | else ajaxSuccess(result, xhr, settings) | ||
213 | } else { | ||
214 | ajaxError(null, xhr.status ? 'error' : 'abort', xhr, settings) | ||
215 | } | ||
216 | } | ||
217 | } | ||
218 | |||
219 | var async = 'async' in settings ? settings.async : true | ||
220 | xhr.open(settings.type, settings.url, async) | ||
221 | |||
222 | for (name in settings.headers) xhr.setRequestHeader(name, settings.headers[name]) | ||
223 | |||
224 | if (ajaxBeforeSend(xhr, settings) === false) { | ||
225 | xhr.abort() | ||
226 | return false | ||
227 | } | ||
228 | |||
229 | if (settings.timeout > 0) abortTimeout = setTimeout(function(){ | ||
230 | xhr.onreadystatechange = empty | ||
231 | xhr.abort() | ||
232 | ajaxError(null, 'timeout', xhr, settings) | ||
233 | }, settings.timeout) | ||
234 | |||
235 | // avoid sending empty string (#319) | ||
236 | xhr.send(settings.data ? settings.data : null) | ||
237 | return xhr | ||
238 | } | ||
239 | |||
240 | $.get = function(url, success){ return $.ajax({ url: url, success: success }) } | ||
241 | |||
242 | $.post = function(url, data, success, dataType){ | ||
243 | if ($.isFunction(data)) dataType = dataType || success, success = data, data = null | ||
244 | return $.ajax({ type: 'POST', url: url, data: data, success: success, dataType: dataType }) | ||
245 | } | ||
246 | |||
247 | $.getJSON = function(url, success){ | ||
248 | return $.ajax({ url: url, success: success, dataType: 'json' }) | ||
249 | } | ||
250 | |||
251 | $.fn.load = function(url, success){ | ||
252 | if (!this.length) return this | ||
253 | var self = this, parts = url.split(/\s/), selector | ||
254 | if (parts.length > 1) url = parts[0], selector = parts[1] | ||
255 | $.get(url, function(response){ | ||
256 | self.html(selector ? | ||
257 | $('<div>').html(response.replace(rscript, "")).find(selector) | ||
258 | : response) | ||
259 | success && success.apply(self, arguments) | ||
260 | }) | ||
261 | return this | ||
262 | } | ||
263 | |||
264 | var escape = encodeURIComponent | ||
265 | |||
266 | function serialize(params, obj, traditional, scope){ | ||
267 | var array = $.isArray(obj) | ||
268 | $.each(obj, function(key, value) { | ||
269 | if (scope) key = traditional ? scope : scope + '[' + (array ? '' : key) + ']' | ||
270 | // handle data in serializeArray() format | ||
271 | if (!scope && array) params.add(value.name, value.value) | ||
272 | // recurse into nested objects | ||
273 | else if (traditional ? $.isArray(value) : isObject(value)) | ||
274 | serialize(params, value, traditional, key) | ||
275 | else params.add(key, value) | ||
276 | }) | ||
277 | } | ||
278 | |||
279 | $.param = function(obj, traditional){ | ||
280 | var params = [] | ||
281 | params.add = function(k, v){ this.push(escape(k) + '=' + escape(v)) } | ||
282 | serialize(params, obj, traditional) | ||
283 | return params.join('&').replace(/%20/g, '+') | ||
284 | } | ||
285 | })(Zepto) | ||