dépôts / lhc / web / www.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
[SPIP][PLUGINS] v3.0-->v3.2
[lhc/web/www.git] / www / prive / javascript / jquery.form.js
1 /*!
2 * jQuery Form Plugin
3 * version: 4.2.2
4 * Requires jQuery v1.7.2 or later
5 * Project repository: https://github.com/jquery-form/form
6
7 * Copyright 2017 Kevin Morris
8 * Copyright 2006 M. Alsup
9
10 * Dual licensed under the LGPL-2.1+ or MIT licenses
11 * https://github.com/jquery-form/form#license
12
13 * This library is free software; you can redistribute it and/or
14 * modify it under the terms of the GNU Lesser General Public
15 * License as published by the Free Software Foundation; either
16 * version 2.1 of the License, or (at your option) any later version.
17 * This library is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20 * Lesser General Public License for more details.
21 */
22 /* global ActiveXObject */
23
24 /* eslint-disable */
25 (function (factory) {
26 if (typeof define === 'function' && define.amd) {
27 // AMD. Register as an anonymous module.
28 define(['jquery'], factory);
29 } else if (typeof module === 'object' && module.exports) {
30 // Node/CommonJS
31 module.exports = function( root, jQuery ) {
32 if (typeof jQuery === 'undefined') {
33 // require('jQuery') returns a factory that requires window to build a jQuery instance, we normalize how we use modules
34 // that require this pattern but the window provided is a noop if it's defined (how jquery works)
35 if (typeof window !== 'undefined') {
36 jQuery = require('jquery');
37 }
38 else {
39 jQuery = require('jquery')(root);
40 }
41 }
42 factory(jQuery);
43 return jQuery;
44 };
45 } else {
46 // Browser globals
47 factory(jQuery);
48 }
49
50 }(function ($) {
51 /* eslint-enable */
52 'use strict';
53
54 /*
55 Usage Note:
56 -----------
57 Do not use both ajaxSubmit and ajaxForm on the same form. These
58 functions are mutually exclusive. Use ajaxSubmit if you want
59 to bind your own submit handler to the form. For example,
60
61 $(document).ready(function() {
62 $('#myForm').on('submit', function(e) {
63 e.preventDefault(); // <-- important
64 $(this).ajaxSubmit({
65 target: '#output'
66 });
67 });
68 });
69
70 Use ajaxForm when you want the plugin to manage all the event binding
71 for you. For example,
72
73 $(document).ready(function() {
74 $('#myForm').ajaxForm({
75 target: '#output'
76 });
77 });
78
79 You can also use ajaxForm with delegation (requires jQuery v1.7+), so the
80 form does not have to exist when you invoke ajaxForm:
81
82 $('#myForm').ajaxForm({
83 delegation: true,
84 target: '#output'
85 });
86
87 When using ajaxForm, the ajaxSubmit function will be invoked for you
88 at the appropriate time.
89 */
90
91 var rCRLF = /\r?\n/g;
92
93 /**
94 * Feature detection
95 */
96 var feature = {};
97
98 feature.fileapi = $('<input type="file">').get(0).files !== undefined;
99 feature.formdata = (typeof window.FormData !== 'undefined');
100
101 var hasProp = !!$.fn.prop;
102
103 // attr2 uses prop when it can but checks the return type for
104 // an expected string. This accounts for the case where a form
105 // contains inputs with names like "action" or "method"; in those
106 // cases "prop" returns the element
107 $.fn.attr2 = function() {
108 if (!hasProp) {
109 return this.attr.apply(this, arguments);
110 }
111
112 var val = this.prop.apply(this, arguments);
113
114 if ((val && val.jquery) || typeof val === 'string') {
115 return val;
116 }
117
118 return this.attr.apply(this, arguments);
119 };
120
121 /**
122 * ajaxSubmit() provides a mechanism for immediately submitting
123 * an HTML form using AJAX.
124 *
125 * @param {object|string} options jquery.form.js parameters or custom url for submission
126 * @param {object} data extraData
127 * @param {string} dataType ajax dataType
128 * @param {function} onSuccess ajax success callback function
129 */
130 $.fn.ajaxSubmit = function(options, data, dataType, onSuccess) {
131 // fast fail if nothing selected (http://dev.jquery.com/ticket/2752)
132 if (!this.length) {
133 log('ajaxSubmit: skipping submit process - no element selected');
134
135 return this;
136 }
137
138 /* eslint consistent-this: ["error", "$form"] */
139 var method, action, url, $form = this;
140
141 if (typeof options === 'function') {
142 options = {success: options};
143
144 } else if (typeof options === 'string' || (options === false && arguments.length > 0)) {
145 options = {
146 'url' : options,
147 'data' : data,
148 'dataType' : dataType
149 };
150
151 if (typeof onSuccess === 'function') {
152 options.success = onSuccess;
153 }
154
155 } else if (typeof options === 'undefined') {
156 options = {};
157 }
158
159 method = options.method || options.type || this.attr2('method');
160 action = options.url || this.attr2('action');
161
162 url = (typeof action === 'string') ? $.trim(action) : '';
163 url = url || window.location.href || '';
164 if (url) {
165 // clean url (don't include hash vaue)
166 url = (url.match(/^([^#]+)/) || [])[1];
167 }
168
169 options = $.extend(true, {
170 url : url,
171 success : $.ajaxSettings.success,
172 type : method || $.ajaxSettings.type,
173 iframeSrc : /^https/i.test(window.location.href || '') ? 'javascript:false' : 'about:blank' // eslint-disable-line no-script-url
174 }, options);
175
176 // hook for manipulating the form data before it is extracted;
177 // convenient for use with rich editors like tinyMCE or FCKEditor
178 var veto = {};
179
180 this.trigger('form-pre-serialize', [this, options, veto]);
181
182 if (veto.veto) {
183 log('ajaxSubmit: submit vetoed via form-pre-serialize trigger');
184
185 return this;
186 }
187
188 // provide opportunity to alter form data before it is serialized
189 if (options.beforeSerialize && options.beforeSerialize(this, options) === false) {
190 log('ajaxSubmit: submit aborted via beforeSerialize callback');
191
192 return this;
193 }
194
195 var traditional = options.traditional;
196
197 if (typeof traditional === 'undefined') {
198 traditional = $.ajaxSettings.traditional;
199 }
200
201 var elements = [];
202 var qx, a = this.formToArray(options.semantic, elements, options.filtering);
203
204 if (options.data) {
205 var optionsData = $.isFunction(options.data) ? options.data(a) : options.data;
206
207 options.extraData = optionsData;
208 qx = $.param(optionsData, traditional);
209 }
210
211 // give pre-submit callback an opportunity to abort the submit
212 if (options.beforeSubmit && options.beforeSubmit(a, this, options) === false) {
213 log('ajaxSubmit: submit aborted via beforeSubmit callback');
214
215 return this;
216 }
217
218 // fire vetoable 'validate' event
219 this.trigger('form-submit-validate', [a, this, options, veto]);
220 if (veto.veto) {
221 log('ajaxSubmit: submit vetoed via form-submit-validate trigger');
222
223 return this;
224 }
225
226 var q = $.param(a, traditional);
227
228 if (qx) {
229 q = (q ? (q + '&' + qx) : qx);
230 }
231
232 if (options.type.toUpperCase() === 'GET') {
233 options.url += (options.url.indexOf('?') >= 0 ? '&' : '?') + q;
234 options.data = null; // data is null for 'get'
235 } else {
236 options.data = q; // data is the query string for 'post'
237 }
238
239 var callbacks = [];
240
241 if (options.resetForm) {
242 callbacks.push(function() {
243 $form.resetForm();
244 });
245 }
246
247 if (options.clearForm) {
248 callbacks.push(function() {
249 $form.clearForm(options.includeHidden);
250 });
251 }
252
253 // perform a load on the target only if dataType is not provided
254 if (!options.dataType && options.target) {
255 var oldSuccess = options.success || function(){};
256
257 callbacks.push(function(data, textStatus, jqXHR) {
258 var successArguments = arguments,
259 fn = options.replaceTarget ? 'replaceWith' : 'html';
260
261 $(options.target)[fn](data).each(function(){
262 oldSuccess.apply(this, successArguments);
263 });
264 });
265
266 } else if (options.success) {
267 if ($.isArray(options.success)) {
268 $.merge(callbacks, options.success);
269 } else {
270 callbacks.push(options.success);
271 }
272 }
273
274 options.success = function(data, status, xhr) { // jQuery 1.4+ passes xhr as 3rd arg
275 var context = options.context || this; // jQuery 1.4+ supports scope context
276
277 for (var i = 0, max = callbacks.length; i < max; i++) {
278 callbacks[i].apply(context, [data, status, xhr || $form, $form]);
279 }
280 };
281
282 if (options.error) {
283 var oldError = options.error;
284
285 options.error = function(xhr, status, error) {
286 var context = options.context || this;
287
288 oldError.apply(context, [xhr, status, error, $form]);
289 };
290 }
291
292 if (options.complete) {
293 var oldComplete = options.complete;
294
295 options.complete = function(xhr, status) {
296 var context = options.context || this;
297
298 oldComplete.apply(context, [xhr, status, $form]);
299 };
300 }
301
302 // are there files to upload?
303
304 // [value] (issue #113), also see comment:
305 // https://github.com/malsup/form/commit/588306aedba1de01388032d5f42a60159eea9228#commitcomment-2180219
306 var fileInputs = $('input[type=file]:enabled', this).filter(function() {
307 return $(this).val() !== '';
308 });
309 var hasFileInputs = fileInputs.length > 0;
310 var mp = 'multipart/form-data';
311 var multipart = ($form.attr('enctype') === mp || $form.attr('encoding') === mp);
312 var fileAPI = feature.fileapi && feature.formdata;
313
314 log('fileAPI :' + fileAPI);
315
316 var shouldUseFrame = (hasFileInputs || multipart) && !fileAPI;
317 var jqxhr;
318
319 // options.iframe allows user to force iframe mode
320 // 06-NOV-09: now defaulting to iframe mode if file input is detected
321 if (options.iframe !== false && (options.iframe || shouldUseFrame)) {
322 // hack to fix Safari hang (thanks to Tim Molendijk for this)
323 // see: http://groups.google.com/group/jquery-dev/browse_thread/thread/36395b7ab510dd5d
324 if (options.closeKeepAlive) {
325 $.get(options.closeKeepAlive, function() {
326 jqxhr = fileUploadIframe(a);
327 });
328
329 } else {
330 jqxhr = fileUploadIframe(a);
331 }
332
333 } else if ((hasFileInputs || multipart) && fileAPI) {
334 jqxhr = fileUploadXhr(a);
335
336 } else {
337 jqxhr = $.ajax(options);
338 }
339
340 $form.removeData('jqxhr').data('jqxhr', jqxhr);
341
342 // clear element array
343 for (var k = 0; k < elements.length; k++) {
344 elements[k] = null;
345 }
346
347 // fire 'notify' event
348 this.trigger('form-submit-notify', [this, options]);
349
350 return this;
351
352 // utility fn for deep serialization
353 function deepSerialize(extraData) {
354 var serialized = $.param(extraData, options.traditional).split('&');
355 var len = serialized.length;
356 var result = [];
357 var i, part;
358
359 for (i = 0; i < len; i++) {
360 // #252; undo param space replacement
361 serialized[i] = serialized[i].replace(/\+/g, ' ');
362 part = serialized[i].split('=');
363 // #278; use array instead of object storage, favoring array serializations
364 result.push([decodeURIComponent(part[0]), decodeURIComponent(part[1])]);
365 }
366
367 return result;
368 }
369
370 // XMLHttpRequest Level 2 file uploads (big hat tip to francois2metz)
371 function fileUploadXhr(a) {
372 var formdata = new FormData();
373
374 for (var i = 0; i < a.length; i++) {
375 formdata.append(a[i].name, a[i].value);
376 }
377
378 if (options.extraData) {
379 var serializedData = deepSerialize(options.extraData);
380
381 for (i = 0; i < serializedData.length; i++) {
382 if (serializedData[i]) {
383 formdata.append(serializedData[i][0], serializedData[i][1]);
384 }
385 }
386 }
387
388 options.data = null;
389
390 var s = $.extend(true, {}, $.ajaxSettings, options, {
391 contentType : false,
392 processData : false,
393 cache : false,
394 type : method || 'POST'
395 });
396
397 if (options.uploadProgress) {
398 // workaround because jqXHR does not expose upload property
399 s.xhr = function() {
400 var xhr = $.ajaxSettings.xhr();
401
402 if (xhr.upload) {
403 xhr.upload.addEventListener('progress', function(event) {
404 var percent = 0;
405 var position = event.loaded || event.position; /* event.position is deprecated */
406 var total = event.total;
407
408 if (event.lengthComputable) {
409 percent = Math.ceil(position / total * 100);
410 }
411
412 options.uploadProgress(event, position, total, percent);
413 }, false);
414 }
415
416 return xhr;
417 };
418 }
419
420 s.data = null;
421
422 var beforeSend = s.beforeSend;
423
424 s.beforeSend = function(xhr, o) {
425 // Send FormData() provided by user
426 if (options.formData) {
427 o.data = options.formData;
428 } else {
429 o.data = formdata;
430 }
431
432 if (beforeSend) {
433 beforeSend.call(this, xhr, o);
434 }
435 };
436
437 return $.ajax(s);
438 }
439
440 // private function for handling file uploads (hat tip to YAHOO!)
441 function fileUploadIframe(a) {
442 var form = $form[0], el, i, s, g, id, $io, io, xhr, sub, n, timedOut, timeoutHandle;
443 var deferred = $.Deferred();
444
445 // #341
446 deferred.abort = function(status) {
447 xhr.abort(status);
448 };
449
450 if (a) {
451 // ensure that every serialized input is still enabled
452 for (i = 0; i < elements.length; i++) {
453 el = $(elements[i]);
454 if (hasProp) {
455 el.prop('disabled', false);
456 } else {
457 el.removeAttr('disabled');
458 }
459 }
460 }
461
462 s = $.extend(true, {}, $.ajaxSettings, options);
463 s.context = s.context || s;
464 id = 'jqFormIO' + new Date().getTime();
465 var ownerDocument = form.ownerDocument;
466 var $body = $form.closest('body');
467
468 if (s.iframeTarget) {
469 $io = $(s.iframeTarget, ownerDocument);
470 n = $io.attr2('name');
471 if (!n) {
472 $io.attr2('name', id);
473 } else {
474 id = n;
475 }
476
477 } else {
478 $io = $('<iframe name="' + id + '" src="' + s.iframeSrc + '" />', ownerDocument);
479 $io.css({position: 'absolute', top: '-1000px', left: '-1000px'});
480 }
481 io = $io[0];
482
483
484 xhr = { // mock object
485 aborted : 0,
486 responseText : null,
487 responseXML : null,
488 status : 0,
489 statusText : 'n/a',
490 getAllResponseHeaders : function() {},
491 getResponseHeader : function() {},
492 setRequestHeader : function() {},
493 abort : function(status) {
494 var e = (status === 'timeout' ? 'timeout' : 'aborted');
495
496 log('aborting upload... ' + e);
497 this.aborted = 1;
498
499 try { // #214, #257
500 if (io.contentWindow.document.execCommand) {
501 io.contentWindow.document.execCommand('Stop');
502 }
503 } catch (ignore) {}
504
505 $io.attr('src', s.iframeSrc); // abort op in progress
506 xhr.error = e;
507 if (s.error) {
508 s.error.call(s.context, xhr, e, status);
509 }
510
511 if (g) {
512 $.event.trigger('ajaxError', [xhr, s, e]);
513 }
514
515 if (s.complete) {
516 s.complete.call(s.context, xhr, e);
517 }
518 }
519 };
520
521 g = s.global;
522 // trigger ajax global events so that activity/block indicators work like normal
523 if (g && $.active++ === 0) {
524 $.event.trigger('ajaxStart');
525 }
526 if (g) {
527 $.event.trigger('ajaxSend', [xhr, s]);
528 }
529
530 if (s.beforeSend && s.beforeSend.call(s.context, xhr, s) === false) {
531 if (s.global) {
532 $.active--;
533 }
534 deferred.reject();
535
536 return deferred;
537 }
538
539 if (xhr.aborted) {
540 deferred.reject();
541
542 return deferred;
543 }
544
545 // add submitting element to data if we know it
546 sub = form.clk;
547 if (sub) {
548 n = sub.name;
549 if (n && !sub.disabled) {
550 s.extraData = s.extraData || {};
551 s.extraData[n] = sub.value;
552 if (sub.type === 'image') {
553 s.extraData[n + '.x'] = form.clk_x;
554 s.extraData[n + '.y'] = form.clk_y;
555 }
556 }
557 }
558
559 var CLIENT_TIMEOUT_ABORT = 1;
560 var SERVER_ABORT = 2;
561
562 function getDoc(frame) {
563 /* it looks like contentWindow or contentDocument do not
564 * carry the protocol property in ie8, when running under ssl
565 * frame.document is the only valid response document, since
566 * the protocol is know but not on the other two objects. strange?
567 * "Same origin policy" http://en.wikipedia.org/wiki/Same_origin_policy
568 */
569
570 var doc = null;
571
572 // IE8 cascading access check
573 try {
574 if (frame.contentWindow) {
575 doc = frame.contentWindow.document;
576 }
577 } catch (err) {
578 // IE8 access denied under ssl & missing protocol
579 log('cannot get iframe.contentWindow document: ' + err);
580 }
581
582 if (doc) { // successful getting content
583 return doc;
584 }
585
586 try { // simply checking may throw in ie8 under ssl or mismatched protocol
587 doc = frame.contentDocument ? frame.contentDocument : frame.document;
588 } catch (err) {
589 // last attempt
590 log('cannot get iframe.contentDocument: ' + err);
591 doc = frame.document;
592 }
593
594 return doc;
595 }
596
597 // Rails CSRF hack (thanks to Yvan Barthelemy)
598 var csrf_token = $('meta[name=csrf-token]').attr('content');
599 var csrf_param = $('meta[name=csrf-param]').attr('content');
600
601 if (csrf_param && csrf_token) {
602 s.extraData = s.extraData || {};
603 s.extraData[csrf_param] = csrf_token;
604 }
605
606 // take a breath so that pending repaints get some cpu time before the upload starts
607 function doSubmit() {
608 // make sure form attrs are set
609 var t = $form.attr2('target'),
610 a = $form.attr2('action'),
611 mp = 'multipart/form-data',
612 et = $form.attr('enctype') || $form.attr('encoding') || mp;
613
614 // update form attrs in IE friendly way
615 form.setAttribute('target', id);
616 if (!method || /post/i.test(method)) {
617 form.setAttribute('method', 'POST');
618 }
619 if (a !== s.url) {
620 form.setAttribute('action', s.url);
621 }
622
623 // ie borks in some cases when setting encoding
624 if (!s.skipEncodingOverride && (!method || /post/i.test(method))) {
625 $form.attr({
626 encoding : 'multipart/form-data',
627 enctype : 'multipart/form-data'
628 });
629 }
630
631 // support timout
632 if (s.timeout) {
633 timeoutHandle = setTimeout(function() {
634 timedOut = true; cb(CLIENT_TIMEOUT_ABORT);
635 }, s.timeout);
636 }
637
638 // look for server aborts
639 function checkState() {
640 try {
641 var state = getDoc(io).readyState;
642
643 log('state = ' + state);
644 if (state && state.toLowerCase() === 'uninitialized') {
645 setTimeout(checkState, 50);
646 }
647
648 } catch (e) {
649 log('Server abort: ', e, ' (', e.name, ')');
650 cb(SERVER_ABORT); // eslint-disable-line callback-return
651 if (timeoutHandle) {
652 clearTimeout(timeoutHandle);
653 }
654 timeoutHandle = undefined;
655 }
656 }
657
658 // add "extra" data to form if provided in options
659 var extraInputs = [];
660
661 try {
662 if (s.extraData) {
663 for (var n in s.extraData) {
664 if (s.extraData.hasOwnProperty(n)) {
665 // if using the $.param format that allows for multiple values with the same name
666 if ($.isPlainObject(s.extraData[n]) && s.extraData[n].hasOwnProperty('name') && s.extraData[n].hasOwnProperty('value')) {
667 extraInputs.push(
668 $('<input type="hidden" name="' + s.extraData[n].name + '">', ownerDocument).val(s.extraData[n].value)
669 .appendTo(form)[0]);
670 } else {
671 extraInputs.push(
672 $('<input type="hidden" name="' + n + '">', ownerDocument).val(s.extraData[n])
673 .appendTo(form)[0]);
674 }
675 }
676 }
677 }
678
679 if (!s.iframeTarget) {
680 // add iframe to doc and submit the form
681 $io.appendTo($body);
682 }
683
684 if (io.attachEvent) {
685 io.attachEvent('onload', cb);
686 } else {
687 io.addEventListener('load', cb, false);
688 }
689
690 setTimeout(checkState, 15);
691
692 try {
693 form.submit();
694
695 } catch (err) {
696 // just in case form has element with name/id of 'submit'
697 var submitFn = document.createElement('form').submit;
698
699 submitFn.apply(form);
700 }
701
702 } finally {
703 // reset attrs and remove "extra" input elements
704 form.setAttribute('action', a);
705 form.setAttribute('enctype', et); // #380
706 if (t) {
707 form.setAttribute('target', t);
708 } else {
709 $form.removeAttr('target');
710 }
711 $(extraInputs).remove();
712 }
713 }
714
715 if (s.forceSync) {
716 doSubmit();
717 } else {
718 setTimeout(doSubmit, 10); // this lets dom updates render
719 }
720
721 var data, doc, domCheckCount = 50, callbackProcessed;
722
723 function cb(e) {
724 if (xhr.aborted || callbackProcessed) {
725 return;
726 }
727
728 doc = getDoc(io);
729 if (!doc) {
730 log('cannot access response document');
731 e = SERVER_ABORT;
732 }
733 if (e === CLIENT_TIMEOUT_ABORT && xhr) {
734 xhr.abort('timeout');
735 deferred.reject(xhr, 'timeout');
736
737 return;
738
739 } else if (e === SERVER_ABORT && xhr) {
740 xhr.abort('server abort');
741 deferred.reject(xhr, 'error', 'server abort');
742
743 return;
744 }
745
746 if (!doc || doc.location.href === s.iframeSrc) {
747 // response not received yet
748 if (!timedOut) {
749 return;
750 }
751 }
752
753 if (io.detachEvent) {
754 io.detachEvent('onload', cb);
755 } else {
756 io.removeEventListener('load', cb, false);
757 }
758
759 var status = 'success', errMsg;
760
761 try {
762 if (timedOut) {
763 throw 'timeout';
764 }
765
766 var isXml = s.dataType === 'xml' || doc.XMLDocument || $.isXMLDoc(doc);
767
768 log('isXml=' + isXml);
769
770 if (!isXml && window.opera && (doc.body === null || !doc.body.innerHTML)) {
771 if (--domCheckCount) {
772 // in some browsers (Opera) the iframe DOM is not always traversable when
773 // the onload callback fires, so we loop a bit to accommodate
774 log('requeing onLoad callback, DOM not available');
775 setTimeout(cb, 250);
776
777 return;
778 }
779 // let this fall through because server response could be an empty document
780 // log('Could not access iframe DOM after mutiple tries.');
781 // throw 'DOMException: not available';
782 }
783
784 // log('response detected');
785 var docRoot = doc.body ? doc.body : doc.documentElement;
786
787 xhr.responseText = docRoot ? docRoot.innerHTML : null;
788 xhr.responseXML = doc.XMLDocument ? doc.XMLDocument : doc;
789 if (isXml) {
790 s.dataType = 'xml';
791 }
792 xhr.getResponseHeader = function(header){
793 var headers = {'content-type': s.dataType};
794
795 return headers[header.toLowerCase()];
796 };
797 // support for XHR 'status' & 'statusText' emulation :
798 if (docRoot) {
799 xhr.status = Number(docRoot.getAttribute('status')) || xhr.status;
800 xhr.statusText = docRoot.getAttribute('statusText') || xhr.statusText;
801 }
802
803 var dt = (s.dataType || '').toLowerCase();
804 var scr = /(json|script|text)/.test(dt);
805
806 if (scr || s.textarea) {
807 // see if user embedded response in textarea
808 var ta = doc.getElementsByTagName('textarea')[0];
809
810 if (ta) {
811 xhr.responseText = ta.value;
812 // support for XHR 'status' & 'statusText' emulation :
813 xhr.status = Number(ta.getAttribute('status')) || xhr.status;
814 xhr.statusText = ta.getAttribute('statusText') || xhr.statusText;
815
816 } else if (scr) {
817 // account for browsers injecting pre around json response
818 var pre = doc.getElementsByTagName('pre')[0];
819 var b = doc.getElementsByTagName('body')[0];
820
821 if (pre) {
822 xhr.responseText = pre.textContent ? pre.textContent : pre.innerText;
823 } else if (b) {
824 xhr.responseText = b.textContent ? b.textContent : b.innerText;
825 }
826 }
827
828 } else if (dt === 'xml' && !xhr.responseXML && xhr.responseText) {
829 xhr.responseXML = toXml(xhr.responseText); // eslint-disable-line no-use-before-define
830 }
831
832 try {
833 data = httpData(xhr, dt, s); // eslint-disable-line no-use-before-define
834
835 } catch (err) {
836 status = 'parsererror';
837 xhr.error = errMsg = (err || status);
838 }
839
840 } catch (err) {
841 log('error caught: ', err);
842 status = 'error';
843 xhr.error = errMsg = (err || status);
844 }
845
846 if (xhr.aborted) {
847 log('upload aborted');
848 status = null;
849 }
850
851 if (xhr.status) { // we've set xhr.status
852 status = ((xhr.status >= 200 && xhr.status < 300) || xhr.status === 304) ? 'success' : 'error';
853 }
854
855 // ordering of these callbacks/triggers is odd, but that's how $.ajax does it
856 if (status === 'success') {
857 if (s.success) {
858 s.success.call(s.context, data, 'success', xhr);
859 }
860
861 deferred.resolve(xhr.responseText, 'success', xhr);
862
863 if (g) {
864 $.event.trigger('ajaxSuccess', [xhr, s]);
865 }
866
867 } else if (status) {
868 if (typeof errMsg === 'undefined') {
869 errMsg = xhr.statusText;
870 }
871 if (s.error) {
872 s.error.call(s.context, xhr, status, errMsg);
873 }
874 deferred.reject(xhr, 'error', errMsg);
875 if (g) {
876 $.event.trigger('ajaxError', [xhr, s, errMsg]);
877 }
878 }
879
880 if (g) {
881 $.event.trigger('ajaxComplete', [xhr, s]);
882 }
883
884 if (g && !--$.active) {
885 $.event.trigger('ajaxStop');
886 }
887
888 if (s.complete) {
889 s.complete.call(s.context, xhr, status);
890 }
891
892 callbackProcessed = true;
893 if (s.timeout) {
894 clearTimeout(timeoutHandle);
895 }
896
897 // clean up
898 setTimeout(function() {
899 if (!s.iframeTarget) {
900 $io.remove();
901 } else { // adding else to clean up existing iframe response.
902 $io.attr('src', s.iframeSrc);
903 }
904 xhr.responseXML = null;
905 }, 100);
906 }
907
908 var toXml = $.parseXML || function(s, doc) { // use parseXML if available (jQuery 1.5+)
909 if (window.ActiveXObject) {
910 doc = new ActiveXObject('Microsoft.XMLDOM');
911 doc.async = 'false';
912 doc.loadXML(s);
913
914 } else {
915 doc = (new DOMParser()).parseFromString(s, 'text/xml');
916 }
917
918 return (doc && doc.documentElement && doc.documentElement.nodeName !== 'parsererror') ? doc : null;
919 };
920 var parseJSON = $.parseJSON || function(s) {
921 /* jslint evil:true */
922 return window['eval']('(' + s + ')'); // eslint-disable-line dot-notation
923 };
924
925 var httpData = function(xhr, type, s) { // mostly lifted from jq1.4.4
926
927 var ct = xhr.getResponseHeader('content-type') || '',
928 xml = ((type === 'xml' || !type) && ct.indexOf('xml') >= 0),
929 data = xml ? xhr.responseXML : xhr.responseText;
930
931 if (xml && data.documentElement.nodeName === 'parsererror') {
932 if ($.error) {
933 $.error('parsererror');
934 }
935 }
936 if (s && s.dataFilter) {
937 data = s.dataFilter(data, type);
938 }
939 if (typeof data === 'string') {
940 if ((type === 'json' || !type) && ct.indexOf('json') >= 0) {
941 data = parseJSON(data);
942 } else if ((type === 'script' || !type) && ct.indexOf('javascript') >= 0) {
943 $.globalEval(data);
944 }
945 }
946
947 return data;
948 };
949
950 return deferred;
951 }
952 };
953
954 /**
955 * ajaxForm() provides a mechanism for fully automating form submission.
956 *
957 * The advantages of using this method instead of ajaxSubmit() are:
958 *
959 * 1: This method will include coordinates for <input type="image"> elements (if the element
960 * is used to submit the form).
961 * 2. This method will include the submit element's name/value data (for the element that was
962 * used to submit the form).
963 * 3. This method binds the submit() method to the form for you.
964 *
965 * The options argument for ajaxForm works exactly as it does for ajaxSubmit. ajaxForm merely
966 * passes the options argument along after properly binding events for submit elements and
967 * the form itself.
968 */
969 $.fn.ajaxForm = function(options, data, dataType, onSuccess) {
970 if (typeof options === 'string' || (options === false && arguments.length > 0)) {
971 options = {
972 'url' : options,
973 'data' : data,
974 'dataType' : dataType
975 };
976
977 if (typeof onSuccess === 'function') {
978 options.success = onSuccess;
979 }
980 }
981
982 options = options || {};
983 options.delegation = options.delegation && $.isFunction($.fn.on);
984
985 // in jQuery 1.3+ we can fix mistakes with the ready state
986 if (!options.delegation && this.length === 0) {
987 var o = {s: this.selector, c: this.context};
988
989 if (!$.isReady && o.s) {
990 log('DOM not ready, queuing ajaxForm');
991 $(function() {
992 $(o.s, o.c).ajaxForm(options);
993 });
994
995 return this;
996 }
997
998 // is your DOM ready? http://docs.jquery.com/Tutorials:Introducing_$(document).ready()
999 log('terminating; zero elements found by selector' + ($.isReady ? '' : ' (DOM not ready)'));
1000
1001 return this;
1002 }
1003
1004 if (options.delegation) {
1005 $(document)
1006 .off('submit.form-plugin', this.selector, doAjaxSubmit)
1007 .off('click.form-plugin', this.selector, captureSubmittingElement)
1008 .on('submit.form-plugin', this.selector, options, doAjaxSubmit)
1009 .on('click.form-plugin', this.selector, options, captureSubmittingElement);
1010
1011 return this;
1012 }
1013
1014 return this.ajaxFormUnbind()
1015 .on('submit.form-plugin', options, doAjaxSubmit)
1016 .on('click.form-plugin', options, captureSubmittingElement);
1017 };
1018
1019 // private event handlers
1020 function doAjaxSubmit(e) {
1021 /* jshint validthis:true */
1022 var options = e.data;
1023
1024 if (!e.isDefaultPrevented()) { // if event has been canceled, don't proceed
1025 e.preventDefault();
1026 $(e.target).closest('form').ajaxSubmit(options); // #365
1027 }
1028 }
1029
1030 function captureSubmittingElement(e) {
1031 /* jshint validthis:true */
1032 var target = e.target;
1033 var $el = $(target);
1034
1035 if (!$el.is('[type=submit],[type=image]')) {
1036 // is this a child element of the submit el? (ex: a span within a button)
1037 var t = $el.closest('[type=submit]');
1038
1039 if (t.length === 0) {
1040 return;
1041 }
1042 target = t[0];
1043 }
1044
1045 var form = target.form;
1046
1047 form.clk = target;
1048
1049 if (target.type === 'image') {
1050 if (typeof e.offsetX !== 'undefined') {
1051 form.clk_x = e.offsetX;
1052 form.clk_y = e.offsetY;
1053
1054 } else if (typeof $.fn.offset === 'function') {
1055 var offset = $el.offset();
1056
1057 form.clk_x = e.pageX - offset.left;
1058 form.clk_y = e.pageY - offset.top;
1059
1060 } else {
1061 form.clk_x = e.pageX - target.offsetLeft;
1062 form.clk_y = e.pageY - target.offsetTop;
1063 }
1064 }
1065 // clear form vars
1066 setTimeout(function() {
1067 form.clk = form.clk_x = form.clk_y = null;
1068 }, 100);
1069 }
1070
1071
1072 // ajaxFormUnbind unbinds the event handlers that were bound by ajaxForm
1073 $.fn.ajaxFormUnbind = function() {
1074 return this.off('submit.form-plugin click.form-plugin');
1075 };
1076
1077 /**
1078 * formToArray() gathers form element data into an array of objects that can
1079 * be passed to any of the following ajax functions: $.get, $.post, or load.
1080 * Each object in the array has both a 'name' and 'value' property. An example of
1081 * an array for a simple login form might be:
1082 *
1083 * [ { name: 'username', value: 'jresig' }, { name: 'password', value: 'secret' } ]
1084 *
1085 * It is this array that is passed to pre-submit callback functions provided to the
1086 * ajaxSubmit() and ajaxForm() methods.
1087 */
1088 $.fn.formToArray = function(semantic, elements, filtering) {
1089 var a = [];
1090
1091 if (this.length === 0) {
1092 return a;
1093 }
1094
1095 var form = this[0];
1096 var formId = this.attr('id');
1097 var els = (semantic || typeof form.elements === 'undefined') ? form.getElementsByTagName('*') : form.elements;
1098 var els2;
1099
1100 if (els) {
1101 els = $.makeArray(els); // convert to standard array
1102 }
1103
1104 // #386; account for inputs outside the form which use the 'form' attribute
1105 // FinesseRus: in non-IE browsers outside fields are already included in form.elements.
1106 if (formId && (semantic || /(Edge|Trident)\//.test(navigator.userAgent))) {
1107 els2 = $(':input[form="' + formId + '"]').get(); // hat tip @thet
1108 if (els2.length) {
1109 els = (els || []).concat(els2);
1110 }
1111 }
1112
1113 if (!els || !els.length) {
1114 return a;
1115 }
1116
1117 if ($.isFunction(filtering)) {
1118 els = $.map(els, filtering);
1119 }
1120
1121 var i, j, n, v, el, max, jmax;
1122
1123 for (i = 0, max = els.length; i < max; i++) {
1124 el = els[i];
1125 n = el.name;
1126 if (!n || el.disabled) {
1127 continue;
1128 }
1129
1130 if (semantic && form.clk && el.type === 'image') {
1131 // handle image inputs on the fly when semantic == true
1132 if (form.clk === el) {
1133 a.push({name: n, value: $(el).val(), type: el.type});
1134 a.push({name: n + '.x', value: form.clk_x}, {name: n + '.y', value: form.clk_y});
1135 }
1136 continue;
1137 }
1138
1139 v = $.fieldValue(el, true);
1140 if (v && v.constructor === Array) {
1141 if (elements) {
1142 elements.push(el);
1143 }
1144 for (j = 0, jmax = v.length; j < jmax; j++) {
1145 a.push({name: n, value: v[j]});
1146 }
1147
1148 } else if (feature.fileapi && el.type === 'file') {
1149 if (elements) {
1150 elements.push(el);
1151 }
1152
1153 var files = el.files;
1154
1155 if (files.length) {
1156 for (j = 0; j < files.length; j++) {
1157 a.push({name: n, value: files[j], type: el.type});
1158 }
1159 } else {
1160 // #180
1161 a.push({name: n, value: '', type: el.type});
1162 }
1163
1164 } else if (v !== null && typeof v !== 'undefined') {
1165 if (elements) {
1166 elements.push(el);
1167 }
1168 a.push({name: n, value: v, type: el.type, required: el.required});
1169 }
1170 }
1171
1172 if (!semantic && form.clk) {
1173 // input type=='image' are not found in elements array! handle it here
1174 var $input = $(form.clk), input = $input[0];
1175
1176 n = input.name;
1177
1178 if (n && !input.disabled && input.type === 'image') {
1179 a.push({name: n, value: $input.val()});
1180 a.push({name: n + '.x', value: form.clk_x}, {name: n + '.y', value: form.clk_y});
1181 }
1182 }
1183
1184 return a;
1185 };
1186
1187 /**
1188 * Serializes form data into a 'submittable' string. This method will return a string
1189 * in the format: name1=value1&amp;name2=value2
1190 */
1191 $.fn.formSerialize = function(semantic) {
1192 // hand off to jQuery.param for proper encoding
1193 return $.param(this.formToArray(semantic));
1194 };
1195
1196 /**
1197 * Serializes all field elements in the jQuery object into a query string.
1198 * This method will return a string in the format: name1=value1&amp;name2=value2
1199 */
1200 $.fn.fieldSerialize = function(successful) {
1201 var a = [];
1202
1203 this.each(function() {
1204 var n = this.name;
1205
1206 if (!n) {
1207 return;
1208 }
1209
1210 var v = $.fieldValue(this, successful);
1211
1212 if (v && v.constructor === Array) {
1213 for (var i = 0, max = v.length; i < max; i++) {
1214 a.push({name: n, value: v[i]});
1215 }
1216
1217 } else if (v !== null && typeof v !== 'undefined') {
1218 a.push({name: this.name, value: v});
1219 }
1220 });
1221
1222 // hand off to jQuery.param for proper encoding
1223 return $.param(a);
1224 };
1225
1226 /**
1227 * Returns the value(s) of the element in the matched set. For example, consider the following form:
1228 *
1229 * <form><fieldset>
1230 * <input name="A" type="text">
1231 * <input name="A" type="text">
1232 * <input name="B" type="checkbox" value="B1">
1233 * <input name="B" type="checkbox" value="B2">
1234 * <input name="C" type="radio" value="C1">
1235 * <input name="C" type="radio" value="C2">
1236 * </fieldset></form>
1237 *
1238 * var v = $('input[type=text]').fieldValue();
1239 * // if no values are entered into the text inputs
1240 * v === ['','']
1241 * // if values entered into the text inputs are 'foo' and 'bar'
1242 * v === ['foo','bar']
1243 *
1244 * var v = $('input[type=checkbox]').fieldValue();
1245 * // if neither checkbox is checked
1246 * v === undefined
1247 * // if both checkboxes are checked
1248 * v === ['B1', 'B2']
1249 *
1250 * var v = $('input[type=radio]').fieldValue();
1251 * // if neither radio is checked
1252 * v === undefined
1253 * // if first radio is checked
1254 * v === ['C1']
1255 *
1256 * The successful argument controls whether or not the field element must be 'successful'
1257 * (per http://www.w3.org/TR/html4/interact/forms.html#successful-controls).
1258 * The default value of the successful argument is true. If this value is false the value(s)
1259 * for each element is returned.
1260 *
1261 * Note: This method *always* returns an array. If no valid value can be determined the
1262 * array will be empty, otherwise it will contain one or more values.
1263 */
1264 $.fn.fieldValue = function(successful) {
1265 for (var val = [], i = 0, max = this.length; i < max; i++) {
1266 var el = this[i];
1267 var v = $.fieldValue(el, successful);
1268
1269 if (v === null || typeof v === 'undefined' || (v.constructor === Array && !v.length)) {
1270 continue;
1271 }
1272
1273 if (v.constructor === Array) {
1274 $.merge(val, v);
1275 } else {
1276 val.push(v);
1277 }
1278 }
1279
1280 return val;
1281 };
1282
1283 /**
1284 * Returns the value of the field element.
1285 */
1286 $.fieldValue = function(el, successful) {
1287 var n = el.name, t = el.type, tag = el.tagName.toLowerCase();
1288
1289 if (typeof successful === 'undefined') {
1290 successful = true;
1291 }
1292
1293 /* eslint-disable no-mixed-operators */
1294 if (successful && (!n || el.disabled || t === 'reset' || t === 'button' ||
1295 (t === 'checkbox' || t === 'radio') && !el.checked ||
1296 (t === 'submit' || t === 'image') && el.form && el.form.clk !== el ||
1297 tag === 'select' && el.selectedIndex === -1)) {
1298 /* eslint-enable no-mixed-operators */
1299 return null;
1300 }
1301
1302 if (tag === 'select') {
1303 var index = el.selectedIndex;
1304
1305 if (index < 0) {
1306 return null;
1307 }
1308
1309 var a = [], ops = el.options;
1310 var one = (t === 'select-one');
1311 var max = (one ? index + 1 : ops.length);
1312
1313 for (var i = (one ? index : 0); i < max; i++) {
1314 var op = ops[i];
1315
1316 if (op.selected && !op.disabled) {
1317 var v = op.value;
1318
1319 if (!v) { // extra pain for IE...
1320 v = (op.attributes && op.attributes.value && !(op.attributes.value.specified)) ? op.text : op.value;
1321 }
1322
1323 if (one) {
1324 return v;
1325 }
1326
1327 a.push(v);
1328 }
1329 }
1330
1331 return a;
1332 }
1333
1334 return $(el).val().replace(rCRLF, '\r\n');
1335 };
1336
1337 /**
1338 * Clears the form data. Takes the following actions on the form's input fields:
1339 * - input text fields will have their 'value' property set to the empty string
1340 * - select elements will have their 'selectedIndex' property set to -1
1341 * - checkbox and radio inputs will have their 'checked' property set to false
1342 * - inputs of type submit, button, reset, and hidden will *not* be effected
1343 * - button elements will *not* be effected
1344 */
1345 $.fn.clearForm = function(includeHidden) {
1346 return this.each(function() {
1347 $('input,select,textarea', this).clearFields(includeHidden);
1348 });
1349 };
1350
1351 /**
1352 * Clears the selected form elements.
1353 */
1354 $.fn.clearFields = $.fn.clearInputs = function(includeHidden) {
1355 var re = /^(?:color|date|datetime|email|month|number|password|range|search|tel|text|time|url|week)$/i; // 'hidden' is not in this list
1356
1357 return this.each(function() {
1358 var t = this.type, tag = this.tagName.toLowerCase();
1359
1360 if (re.test(t) || tag === 'textarea') {
1361 this.value = '';
1362
1363 } else if (t === 'checkbox' || t === 'radio') {
1364 this.checked = false;
1365
1366 } else if (tag === 'select') {
1367 this.selectedIndex = -1;
1368
1369 } else if (t === 'file') {
1370 if (/MSIE/.test(navigator.userAgent)) {
1371 $(this).replaceWith($(this).clone(true));
1372 } else {
1373 $(this).val('');
1374 }
1375
1376 } else if (includeHidden) {
1377 // includeHidden can be the value true, or it can be a selector string
1378 // indicating a special test; for example:
1379 // $('#myForm').clearForm('.special:hidden')
1380 // the above would clean hidden inputs that have the class of 'special'
1381 if ((includeHidden === true && /hidden/.test(t)) ||
1382 (typeof includeHidden === 'string' && $(this).is(includeHidden))) {
1383 this.value = '';
1384 }
1385 }
1386 });
1387 };
1388
1389
1390 /**
1391 * Resets the form data or individual elements. Takes the following actions
1392 * on the selected tags:
1393 * - all fields within form elements will be reset to their original value
1394 * - input / textarea / select fields will be reset to their original value
1395 * - option / optgroup fields (for multi-selects) will defaulted individually
1396 * - non-multiple options will find the right select to default
1397 * - label elements will be searched against its 'for' attribute
1398 * - all others will be searched for appropriate children to default
1399 */
1400 $.fn.resetForm = function() {
1401 return this.each(function() {
1402 var el = $(this);
1403 var tag = this.tagName.toLowerCase();
1404
1405 switch (tag) {
1406 case 'input':
1407 this.checked = this.defaultChecked;
1408 // fall through
1409
1410 case 'textarea':
1411 this.value = this.defaultValue;
1412
1413 return true;
1414
1415 case 'option':
1416 case 'optgroup':
1417 var select = el.parents('select');
1418
1419 if (select.length && select[0].multiple) {
1420 if (tag === 'option') {
1421 this.selected = this.defaultSelected;
1422 } else {
1423 el.find('option').resetForm();
1424 }
1425 } else {
1426 select.resetForm();
1427 }
1428
1429 return true;
1430
1431 case 'select':
1432 el.find('option').each(function(i) { // eslint-disable-line consistent-return
1433 this.selected = this.defaultSelected;
1434 if (this.defaultSelected && !el[0].multiple) {
1435 el[0].selectedIndex = i;
1436
1437 return false;
1438 }
1439 });
1440
1441 return true;
1442
1443 case 'label':
1444 var forEl = $(el.attr('for'));
1445 var list = el.find('input,select,textarea');
1446
1447 if (forEl[0]) {
1448 list.unshift(forEl[0]);
1449 }
1450
1451 list.resetForm();
1452
1453 return true;
1454
1455 case 'form':
1456 // guard against an input with the name of 'reset'
1457 // note that IE reports the reset function as an 'object'
1458 if (typeof this.reset === 'function' || (typeof this.reset === 'object' && !this.reset.nodeType)) {
1459 this.reset();
1460 }
1461
1462 return true;
1463
1464 default:
1465 el.find('form,input,label,select,textarea').resetForm();
1466
1467 return true;
1468 }
1469 });
1470 };
1471
1472 /**
1473 * Enables or disables any matching elements.
1474 */
1475 $.fn.enable = function(b) {
1476 if (typeof b === 'undefined') {
1477 b = true;
1478 }
1479
1480 return this.each(function() {
1481 this.disabled = !b;
1482 });
1483 };
1484
1485 /**
1486 * Checks/unchecks any matching checkboxes or radio buttons and
1487 * selects/deselects and matching option elements.
1488 */
1489 $.fn.selected = function(select) {
1490 if (typeof select === 'undefined') {
1491 select = true;
1492 }
1493
1494 return this.each(function() {
1495 var t = this.type;
1496
1497 if (t === 'checkbox' || t === 'radio') {
1498 this.checked = select;
1499
1500 } else if (this.tagName.toLowerCase() === 'option') {
1501 var $sel = $(this).parent('select');
1502
1503 if (select && $sel[0] && $sel[0].type === 'select-one') {
1504 // deselect all other options
1505 $sel.find('option').selected(false);
1506 }
1507
1508 this.selected = select;
1509 }
1510 });
1511 };
1512
1513 // expose debug var
1514 $.fn.ajaxSubmit.debug = false;
1515
1516 // helper fn for console logging
1517 function log() {
1518 if (!$.fn.ajaxSubmit.debug) {
1519 return;
1520 }
1521
1522 var msg = '[jquery.form] ' + Array.prototype.join.call(arguments, '');
1523
1524 if (window.console && window.console.log) {
1525 window.console.log(msg);
1526
1527 } else if (window.opera && window.opera.postError) {
1528 window.opera.postError(msg);
1529 }
1530 }
1531 }));
Site oueb de l'Heureux Cyclage