]> CyberLeo.Net >> Repos - Github/sugarcrm.git/blob - jssource/src_files/include/javascript/yui3/build/io/io.js
Release 6.5.0
[Github/sugarcrm.git] / jssource / src_files / include / javascript / yui3 / build / io / io.js
1 /*
2 Copyright (c) 2010, Yahoo! Inc. All rights reserved.
3 Code licensed under the BSD License:
4 http://developer.yahoo.com/yui/license.html
5 version: 3.3.0
6 build: 3167
7 */
8 YUI.add('io-base', function(Y) {
9
10    /**
11     * Base IO functionality. Provides basic XHR transport support.
12     * @module io
13     * @submodule io-base
14     */
15
16    /**
17     * The io class is a utility that brokers HTTP requests through a simplified
18     * interface.  Specifically, it allows JavaScript to make HTTP requests to
19     * a resource without a page reload.  The underlying transport for making
20     * same-domain requests is the XMLHttpRequest object.  YUI.io can also use
21     * Flash, if specified as a transport, for cross-domain requests.
22     *
23     * @class io
24     */
25
26    /**
27     * @event io:start
28     * @description This event is fired by YUI.io when a transaction is initiated.
29     * @type Event Custom
30     */
31     var E_START = 'io:start',
32
33    /**
34     * @event io:complete
35     * @description This event is fired by YUI.io when a transaction is complete.
36     * Response status and data are accessible, if available.
37     * @type Event Custom
38     */
39     E_COMPLETE = 'io:complete',
40
41    /**
42     * @event io:success
43     * @description This event is fired by YUI.io when a transaction is complete, and
44     * the HTTP status resolves to HTTP2xx.
45     * @type Event Custom
46     */
47     E_SUCCESS = 'io:success',
48
49    /**
50     * @event io:failure
51     * @description This event is fired by YUI.io when a transaction is complete, and
52     * the HTTP status resolves to HTTP4xx, 5xx and above.
53     * @type Event Custom
54     */
55     E_FAILURE = 'io:failure',
56
57    /**
58     * @event io:end
59     * @description This event signifies the end of the transaction lifecycle.  The
60     * transaction transport is destroyed.
61     * @type Event Custom
62     */
63     E_END = 'io:end',
64
65     //--------------------------------------
66     //  Properties
67     //--------------------------------------
68    /**
69     * @description A transaction counter that increments for each transaction.
70     *
71     * @property transactionId
72     * @private
73     * @static
74     * @type int
75     */
76     transactionId = 0,
77
78    /**
79     * @description Object of default HTTP headers to be initialized and sent
80     * for all transactions.
81     *
82     * @property _headers
83     * @private
84     * @static
85     * @type object
86     */
87     _headers = {
88         'X-Requested-With' : 'XMLHttpRequest'
89     },
90
91    /**
92     * @description Object that stores timeout values for any transaction with
93     * a defined "timeout" configuration property.
94     *
95     * @property _timeout
96     * @private
97     * @static
98     * @type object
99     */
100     _timeout = {},
101
102     // Window reference
103     w = Y.config.win;
104
105     //--------------------------------------
106     //  Methods
107     //--------------------------------------
108
109    /**
110     * @description Method that creates the XMLHttpRequest transport
111     *
112     * @method _xhr
113     * @private
114     * @static
115     * @return object
116     */
117     function _xhr() {
118         return w.XMLHttpRequest ? new XMLHttpRequest() : new ActiveXObject('Microsoft.XMLHTTP');
119     }
120
121
122    /**
123     * @description Method that increments _transactionId for each transaction.
124     *
125     * @method _id
126     * @private
127     * @static
128     * @return int
129     */
130     function _id() {
131         var id = transactionId;
132
133         transactionId++;
134
135         return id;
136     }
137
138    /**
139     * @description Method that creates a unique transaction object for each
140     * request.
141     *
142     * @method _create
143     * @private
144     * @static
145     * @param {number} c - configuration object subset to determine if
146     *                     the transaction is an XDR or file upload,
147     *                     requiring an alternate transport.
148     * @param {number} i - transaction id
149     * @return object
150     */
151     function _create(c, i) {
152         var o = {};
153             o.id = Y.Lang.isNumber(i) ? i : _id();
154             c = c || {};
155
156         if (!c.use && !c.upload) {
157             o.c = _xhr();
158         }
159         else if (c.use) {
160             if (c.use === 'native') {
161                 if (w.XDomainRequest) {
162                     o.c = new XDomainRequest();
163                     o.t = c.use;
164                 }
165                 else {
166                     o.c = _xhr();
167                 }
168             }
169             else {
170                 o.c = Y.io._transport[c.use];
171                 o.t = c.use;
172             }
173         }
174         else {
175             o.c = {};
176                         o.t = 'io:iframe';
177         }
178
179         return o;
180     }
181
182
183     function _destroy(o) {
184         if (w) {
185             if (o.c && w.XMLHttpRequest) {
186                 o.c.onreadystatechange = null;
187             }
188                         else if (Y.UA.ie === 6 && !o.t) {
189                                 // IE, when using XMLHttpRequest as an ActiveX Object, will throw
190                                 // a "Type Mismatch" error if the event handler is set to "null".
191                                 o.c.abort();
192                         }
193         }
194
195         o.c = null;
196         o = null;
197     }
198
199    /**
200     * @description Method for creating and subscribing transaction events.
201     *
202     * @method _tE
203     * @private
204     * @static
205     * @param {string} e - event to be published
206     * @param {object} c - configuration data subset for event subscription.
207     *
208     * @return void
209     */
210     function _tE(e, c) {
211         var eT = new Y.EventTarget().publish('transaction:' + e),
212             a = c.arguments,
213             cT = c.context || Y;
214
215         if (a) {
216             eT.on(c.on[e], cT, a);
217         }
218         else {
219             eT.on(c.on[e], cT);
220         }
221
222         return eT;
223     }
224
225    /**
226     * @description Fires event "io:start" and creates, fires a
227     * transaction-specific start event, if config.on.start is
228     * defined.
229     *
230     * @method _ioStart
231     * @private
232     * @static
233     * @param {number} id - transaction id
234     * @param {object} c - configuration object for the transaction.
235     *
236     * @return void
237     */
238     function _ioStart(id, c) {
239         var a = c.arguments;
240
241         if (a) {
242             Y.fire(E_START, id, a);
243         }
244         else {
245             Y.fire(E_START, id);
246         }
247
248         if (c.on && c.on.start) {
249             _tE('start', c).fire(id);
250         }
251     }
252
253
254    /**
255     * @description Fires event "io:complete" and creates, fires a
256     * transaction-specific "complete" event, if config.on.complete is
257     * defined.
258     *
259     * @method _ioComplete
260     * @private
261     * @static
262     * @param {object} o - transaction object.
263     * @param {object} c - configuration object for the transaction.
264     *
265     * @return void
266     */
267     function _ioComplete(o, c) {
268         var r = o.e ? { status: 0, statusText: o.e } : o.c,
269             a = c.arguments;
270
271         if (a) {
272             Y.fire(E_COMPLETE, o.id, r, a);
273         }
274         else {
275             Y.fire(E_COMPLETE, o.id, r);
276         }
277
278         if (c.on && c.on.complete) {
279             _tE('complete', c).fire(o.id, r);
280         }
281     }
282
283    /**
284     * @description Fires event "io:end" and creates, fires a
285     * transaction-specific "end" event, if config.on.end is
286     * defined.
287     *
288     * @method _ioEnd
289     * @private
290     * @static
291     * @param {object} o - transaction object.
292     * @param {object} c - configuration object for the transaction.
293     *
294     * @return void
295     */
296     function _ioEnd(o, c) {
297         var a = c.arguments;
298
299         if (a) {
300             Y.fire(E_END, o.id, a);
301         }
302         else {
303             Y.fire(E_END, o.id);
304         }
305
306         if (c.on && c.on.end) {
307             _tE('end', c).fire(o.id);
308         }
309
310         _destroy(o);
311     }
312
313    /**
314     * @description Fires event "io:success" and creates, fires a
315     * transaction-specific "success" event, if config.on.success is
316     * defined.
317     *
318     * @method _ioSuccess
319     * @private
320     * @static
321     * @param {object} o - transaction object.
322     * @param {object} c - configuration object for the transaction.
323     *
324     * @return void
325     */
326     function _ioSuccess(o, c) {
327         var a = c.arguments;
328
329         if (a) {
330             Y.fire(E_SUCCESS, o.id, o.c, a);
331         }
332         else {
333             Y.fire(E_SUCCESS, o.id, o.c);
334         }
335
336         if (c.on && c.on.success) {
337             _tE('success', c).fire(o.id, o.c);
338         }
339
340         _ioEnd(o, c);
341     }
342
343    /**
344     * @description Fires event "io:failure" and creates, fires a
345     * transaction-specific "failure" event, if config.on.failure is
346     * defined.
347     *
348     * @method _ioFailure
349     * @private
350     * @static
351     * @param {object} o - transaction object.
352     * @param {object} c - configuration object for the transaction.
353     *
354     * @return void
355     */
356     function _ioFailure(o, c) {
357         var r = o.e ? { status: 0, statusText: o.e } : o.c,
358             a = c.arguments;
359
360         if (a) {
361             Y.fire(E_FAILURE, o.id, r, a);
362         }
363         else {
364             Y.fire(E_FAILURE, o.id, r);
365         }
366
367         if (c.on && c.on.failure) {
368             _tE('failure', c).fire(o.id, r);
369         }
370
371         _ioEnd(o, c);
372     }
373
374    /**
375     * @description Resends an XDR transaction, using the Flash tranport,
376     * if the native transport fails.
377     *
378     * @method _resend
379     * @private
380     * @static
381
382     * @param {object} o - Transaction object generated by _create().
383     * @param {string} uri - qualified path to transaction resource.
384     * @param {object} c - configuration object for the transaction.
385     *
386     * @return void
387     */
388     function _resend(o, uri, c, d) {
389         _destroy(o);
390         c.xdr.use = 'flash';
391         // If the original request included serialized form data and
392         // additional data are defined in configuration.data, it must
393         // be reset to prevent data duplication.
394         c.data = c.form && d ? d : null;
395
396         return Y.io(uri, c, o.id);
397     }
398
399    /**
400     * @description Method that concatenates string data for HTTP GET transactions.
401     *
402     * @method _concat
403     * @private
404     * @static
405     * @param {string} s - URI or root data.
406     * @param {string} d - data to be concatenated onto URI.
407     * @return int
408     */
409     function _concat(s, d) {
410         s += ((s.indexOf('?') == -1) ? '?' : '&') + d;
411         return s;
412     }
413
414    /**
415     * @description Method that stores default client headers for all transactions.
416     * If a label is passed with no value argument, the header will be deleted.
417     *
418     * @method _setHeader
419     * @private
420     * @static
421     * @param {string} l - HTTP header
422     * @param {string} v - HTTP header value
423     * @return int
424     */
425     function _setHeader(l, v) {
426         if (v) {
427             _headers[l] = v;
428         }
429         else {
430             delete _headers[l];
431         }
432     }
433
434    /**
435     * @description Method that sets all HTTP headers to be sent in a transaction.
436     *
437     * @method _setHeaders
438     * @private
439     * @static
440     * @param {object} o - XHR instance for the specific transaction.
441     * @param {object} h - HTTP headers for the specific transaction, as defined
442     *                     in the configuration object passed to YUI.io().
443     * @return void
444     */
445     function _setHeaders(o, h) {
446         var p;
447             h = h || {};
448
449         for (p in _headers) {
450             if (_headers.hasOwnProperty(p)) {
451                                 /*
452                 if (h[p]) {
453                     // Configuration headers will supersede preset io headers,
454                     // if headers match.
455                     continue;
456                 }
457                 else {
458                     h[p] = _headers[p];
459                 }
460                                 */
461                                 if (!h[p]) {
462                                         h[p] = _headers[p];
463                                 }
464             }
465         }
466
467         for (p in h) {
468             if (h.hasOwnProperty(p)) {
469                                 if (h[p] !== 'disable') {
470                         o.setRequestHeader(p, h[p]);
471                                 }
472                         }
473         }
474     }
475
476    /**
477     * @description Terminates a transaction due to an explicit abort or
478     * timeout.
479     *
480     * @method _ioCancel
481     * @private
482     * @static
483     * @param {object} o - Transaction object generated by _create().
484     * @param {string} s - Identifies timed out or aborted transaction.
485     *
486     * @return void
487     */
488     function _ioCancel(o, s) {
489         if (o && o.c) {
490             o.e = s;
491             o.c.abort();
492         }
493     }
494
495    /**
496     * @description Starts timeout count if the configuration object
497     * has a defined timeout property.
498     *
499     * @method _startTimeout
500     * @private
501     * @static
502     * @param {object} o - Transaction object generated by _create().
503     * @param {object} t - Timeout in milliseconds.
504     * @return void
505     */
506     function _startTimeout(o, t) {
507         _timeout[o.id] = w.setTimeout(function() { _ioCancel(o, 'timeout'); }, t);
508     }
509
510    /**
511     * @description Clears the timeout interval started by _startTimeout().
512     *
513     * @method _clearTimeout
514     * @private
515     * @static
516     * @param {number} id - Transaction id.
517     * @return void
518     */
519     function _clearTimeout(id) {
520         w.clearTimeout(_timeout[id]);
521         delete _timeout[id];
522     }
523
524    /**
525     * @description Method that determines if a transaction response qualifies
526     * as success or failure, based on the response HTTP status code, and
527     * fires the appropriate success or failure events.
528     *
529     * @method _handleResponse
530     * @private
531     * @static
532     * @param {object} o - Transaction object generated by _create().
533     * @param {object} c - Configuration object passed to io().
534     * @return void
535     */
536     function _handleResponse(o, c) {
537         var status;
538
539         try {
540                         status = (o.c.status && o.c.status !== 0) ? o.c.status : 0;
541         }
542         catch(e) {
543             status = 0;
544         }
545
546         // IE reports HTTP 204 as HTTP 1223.
547         if (status >= 200 && status < 300 || status === 1223) {
548             _ioSuccess(o, c);
549         }
550         else {
551             _ioFailure(o, c);
552         }
553     }
554
555    /**
556     * @description Event handler bound to onreadystatechange.
557     *
558     * @method _readyState
559     * @private
560     * @static
561     * @param {object} o - Transaction object generated by _create().
562     * @param {object} c - Configuration object passed to YUI.io().
563     * @return void
564     */
565     function _readyState(o, c) {
566         if (o.c.readyState === 4) {
567             if (c.timeout) {
568                 _clearTimeout(o.id);
569             }
570
571             w.setTimeout(
572                 function() {
573                     _ioComplete(o, c);
574                     _handleResponse(o, c);
575                 }, 0);
576         }
577     }
578
579    /**
580     * @description Method for requesting a transaction. _io() is implemented as
581     * yui.io().  Each transaction may include a configuration object.  Its
582     * properties are:
583     *
584     * method: HTTP method verb (e.g., GET or POST). If this property is not
585     *         not defined, the default value will be GET.
586     *
587     * data: This is the name-value string that will be sent as the transaction
588     *       data.  If the request is HTTP GET, the data become part of
589     *       querystring. If HTTP POST, the data are sent in the message body.
590     *
591     * xdr: Defines the transport to be used for cross-domain requests.  By
592     *      setting this property, the transaction will use the specified
593     *      transport instead of XMLHttpRequest.
594     *      The properties are:
595     *      {
596     *        use: Specify the transport to be used: 'flash' and 'native'
597     *        dataType: Set the value to 'XML' if that is the expected
598     *                  response content type.
599     *      }
600     *
601     *
602     * form: This is a defined object used to process HTML form as data.  The
603     *       properties are:
604     *       {
605     *         id: Node object or id of HTML form.
606     *         useDisabled: Boolean value to allow disabled HTML form field
607     *                      values to be sent as part of the data.
608     *       }
609     *
610     * on: This is a defined object used to create and handle specific
611     *     events during a transaction lifecycle.  These events will fire in
612     *     addition to the global io events. The events are:
613     *     start - This event is fired when a request is sent to a resource.
614     *     complete - This event fires when the transaction is complete.
615     *     success - This event fires when the response status resolves to
616     *               HTTP 2xx.
617     *     failure - This event fires when the response status resolves to
618     *               HTTP 4xx, 5xx; and, for all transaction exceptions,
619     *               including aborted transactions and transaction timeouts.
620     *     end -  This even is fired at the conclusion of the transaction
621     *            lifecycle, after a success or failure resolution.
622     *
623     *     The properties are:
624     *     {
625     *       start: function(id, arguments){},
626     *       complete: function(id, responseobject, arguments){},
627     *       success: function(id, responseobject, arguments){},
628     *       failure: function(id, responseobject, arguments){},
629     *       end: function(id, arguments){}
630     *     }
631     *     Each property can reference a function or be written as an
632     *     inline function.
633     *
634     * sync: To enable synchronous transactions, set the configuration property
635     *       "sync" to true; the default behavior is false.  Synchronous
636     *       transactions are limited to same-domain requests only.
637     *
638     * context: Object reference for all defined transaction event handlers
639     *          when it is implemented as a method of a base object. Defining
640     *          "context" will set the reference of "this," used in the
641     *          event handlers, to the context value.  In the case where
642     *          different event handlers all have different contexts,
643     *          use Y.bind() to set the execution context, bypassing this
644     *          configuration.
645     *
646     * headers: This is a defined object of client headers, as many as.
647     *          desired for the transaction.  The object pattern is:
648     *          { 'header': 'value' }.
649     *
650     * timeout: This value, defined as milliseconds, is a time threshold for the
651     *          transaction. When this threshold is reached, and the transaction's
652     *          Complete event has not yet fired, the transaction will be aborted.
653     *
654     * arguments: Object, array, string, or number passed to all registered
655     *            event handlers.  This value is available as the second
656     *            argument in the "start" and "abort" event handlers; and, it is
657     *            the third argument in the "complete", "success", and "failure"
658     *            event handlers.
659     *
660     * @method _io
661     * @private
662     * @static
663     * @param {string} uri - qualified path to transaction resource.
664     * @param {object} c - configuration object for the transaction.
665     * @param {number} i - transaction id, if already set.
666     * @return object
667     */
668     function _io(uri, c, i) {
669         var f, o, d, m, r, s, oD, a, j,
670             u = uri;
671             c = Y.Object(c);
672             o = _create(c.xdr || c.form, i);
673             m = c.method ? c.method = c.method.toUpperCase() : c.method = 'GET';
674             s = c.sync;
675             oD = c.data;
676
677         //To serialize an object into a key-value string, add the
678         //QueryString module to the YUI instance's 'use' method.
679         if (Y.Lang.isObject(c.data) && Y.QueryString) {
680             c.data = Y.QueryString.stringify(c.data);
681         }
682
683         if (c.form) {
684             if (c.form.upload) {
685                 // This is a file upload transaction, calling
686                 // upload() in io-upload-iframe.
687                 return Y.io.upload(o, uri, c);
688             }
689             else {
690                 // Serialize HTML form data.
691                 f = Y.io._serialize(c.form, c.data);
692                 if (m === 'POST' || m === 'PUT') {
693                     c.data = f;
694                 }
695                 else if (m === 'GET') {
696                     uri = _concat(uri, f);
697                 }
698             }
699         }
700
701         if (c.data && m === 'GET') {
702             uri = _concat(uri, c.data);
703         }
704
705         if (c.data && m === 'POST') {
706             c.headers = Y.merge({ 'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8' }, c.headers);
707         }
708
709         if (o.t) {
710             return Y.io.xdr(uri, o, c);
711         }
712
713         if (!s) {
714             o.c.onreadystatechange = function() { _readyState(o, c); };
715         }
716
717         try {
718             o.c.open(m, uri, s ? false : true);
719             // Will work only in browsers that implement the
720             // Cross-Origin Resource Sharing draft.
721             if (c.xdr && c.xdr.credentials) {
722                 o.c.withCredentials = true;
723             }
724         }
725         catch(e1) {
726             if (c.xdr) {
727                 // This exception is usually thrown by browsers
728                 // that do not support native XDR transactions.
729                 return _resend(o, u, c, oD);
730             }
731         }
732
733         _setHeaders(o.c, c.headers);
734         _ioStart(o.id, c);
735         try {
736             // Using "null" with HTTP POST will  result in a request
737             // with no Content-Length header defined.
738             o.c.send(c.data || '');
739             if (s) {
740                 d = o.c;
741                 a  = ['status', 'statusText', 'responseText', 'responseXML'];
742                 r = c.arguments ? { id: o.id, arguments: c.arguments } : { id: o.id };
743
744                 for (j = 0; j < 4; j++) {
745                     r[a[j]] = o.c[a[j]];
746                 }
747
748                 r.getAllResponseHeaders = function() { return d.getAllResponseHeaders(); };
749                 r.getResponseHeader = function(h) { return d.getResponseHeader(h); };
750                 _ioComplete(o, c);
751                 _handleResponse(o, c);
752
753                 return r;
754             }
755         }
756         catch(e2) {
757             if (c.xdr) {
758                 // This exception is usually thrown by browsers
759                 // that do not support native XDR transactions.
760                 return _resend(o, u, c, oD);
761             }
762         }
763
764         // If config.timeout is defined, and the request is standard XHR,
765         // initialize timeout polling.
766         if (c.timeout) {
767             _startTimeout(o, c.timeout);
768         }
769
770         return {
771             id: o.id,
772             abort: function() {
773                 return o.c ? _ioCancel(o, 'abort') : false;
774             },
775             isInProgress: function() {
776                 return o.c ? o.c.readyState !== 4 && o.c.readyState !== 0 : false;
777             }
778         };
779     }
780
781     _io.start = _ioStart;
782     _io.complete = _ioComplete;
783     _io.success = _ioSuccess;
784     _io.failure = _ioFailure;
785     _io.end = _ioEnd;
786     _io._id = _id;
787     _io._timeout = _timeout;
788
789     //--------------------------------------
790     //  Begin public interface definition
791     //--------------------------------------
792    /**
793     * @description Method that stores default client headers for all transactions.
794     * If a label is passed with no value argument, the header will be deleted.
795     * This is the interface for _setHeader().
796     *
797     * @method header
798     * @public
799     * @static
800     * @param {string} l - HTTP header
801     * @param {string} v - HTTP header value
802     * @return int
803     */
804     _io.header = _setHeader;
805
806    /**
807     * @description Method for requesting a transaction. This
808     * is the interface for _io().
809     *
810     * @method io
811     * @public
812     * @static
813     * @param {string} uri - qualified path to transaction resource.
814     * @param {object} c - configuration object for the transaction.
815     * @return object
816     */
817     Y.io = _io;
818     Y.io.http = _io;
819
820
821
822 }, '3.3.0' ,{requires:['event-custom-base', 'querystring-stringify-simple']});
823
824 YUI.add('io-form', function(Y) {
825
826    /**
827     * Extends the IO base class to enable HTML form data serialization, when specified
828     * in the transaction's configuration object.
829     * @module io
830     * @submodule io-form
831     */
832
833     var eUC = encodeURIComponent;
834
835     Y.mix(Y.io, {
836        /**
837         * @description Method to enumerate through an HTML form's elements collection
838         * and return a string comprised of key-value pairs.
839         *
840         * @method _serialize
841         * @private
842         * @static
843         * @param {object} c - YUI form node or HTML form id.
844         * @param {string} s - Transaction data defined in the configuration.
845         * @return string
846         */
847         _serialize: function(c, s) {
848             var data = [],
849                 useDf = c.useDisabled || false,
850                 item = 0,
851                 id = (typeof c.id === 'string') ? c.id : c.id.getAttribute('id'),
852                 e, f, n, v, d, i, il, j, jl, o;
853
854                 if (!id) {
855                     id = Y.guid('io:');
856                     c.id.setAttribute('id', id);
857                 }
858
859                 f = Y.config.doc.getElementById(id);
860
861             // Iterate over the form elements collection to construct the
862             // label-value pairs.
863             for (i = 0, il = f.elements.length; i < il; ++i) {
864                 e = f.elements[i];
865                 d = e.disabled;
866                 n = e.name;
867
868                 if (useDf ? n : n && !d) {
869                     n = eUC(n) + '=';
870                     v = eUC(e.value);
871
872                     switch (e.type) {
873                         // Safari, Opera, FF all default options.value from .text if
874                         // value attribute not specified in markup
875                         case 'select-one':
876                             if (e.selectedIndex > -1) {
877                                 o = e.options[e.selectedIndex];
878                                 data[item++] = n + eUC(o.attributes.value && o.attributes.value.specified ? o.value : o.text);
879                             }
880                             break;
881                         case 'select-multiple':
882                             if (e.selectedIndex > -1) {
883                                 for (j = e.selectedIndex, jl = e.options.length; j < jl; ++j) {
884                                     o = e.options[j];
885                                     if (o.selected) {
886                                       data[item++] = n + eUC(o.attributes.value && o.attributes.value.specified ? o.value : o.text);
887                                     }
888                                 }
889                             }
890                             break;
891                         case 'radio':
892                         case 'checkbox':
893                             if (e.checked) {
894                                 data[item++] = n + v;
895                             }
896                             break;
897                         case 'file':
898                             // stub case as XMLHttpRequest will only send the file path as a string.
899                         case undefined:
900                             // stub case for fieldset element which returns undefined.
901                         case 'reset':
902                             // stub case for input type reset button.
903                         case 'button':
904                             // stub case for input type button elements.
905                             break;
906                         case 'submit':
907                         default:
908                             data[item++] = n + v;
909                     }
910                 }
911             }
912             return s ? data.join('&') + "&" + s : data.join('&');
913         }
914     }, true);
915
916
917
918 }, '3.3.0' ,{requires:['io-base','node-base']});
919
920 YUI.add('io-xdr', function(Y) {
921
922    /**
923     * Extends the IO base class to provide an alternate, Flash transport, for making
924     * cross-domain requests.
925     * @module io
926     * @submodule io-xdr
927     */
928
929    /**
930     * @event io:xdrReady
931     * @description This event is fired by YUI.io when the specified transport is
932     * ready for use.
933     * @type Event Custom
934     */
935     var E_XDR_READY = Y.publish('io:xdrReady', { fireOnce: true }),
936
937    /**
938     * @description Object that stores callback handlers for cross-domain requests
939     * when using Flash as the transport.
940     *
941     * @property _cB
942     * @private
943     * @static
944     * @type object
945     */
946     _cB = {},
947
948    /**
949     * @description Map of transaction readyState values used when
950     * XDomainRequest is the XDR transport.
951     *
952     * @property _rS
953     * @private
954     * @static
955     * @type object
956     */
957     _rS = {},
958
959     // Document reference
960     d = Y.config.doc,
961     // Window reference
962     w = Y.config.win,
963         // IE8 cross-origin request detection
964     ie = w && w.XDomainRequest;
965
966    /**
967     * @description Method that creates the Flash transport swf.
968     *
969     * @method _swf
970     * @private
971     * @static
972     * @param {string} uri - location of io.swf.
973     * @param {string} yid - YUI instance id.
974     * @return void
975     */
976     function _swf(uri, yid) {
977         var o = '<object id="yuiIoSwf" type="application/x-shockwave-flash" data="' +
978                 uri + '" width="0" height="0">' +
979                 '<param name="movie" value="' + uri + '">' +
980                 '<param name="FlashVars" value="yid=' + yid + '">' +
981                 '<param name="allowScriptAccess" value="always">' +
982                 '</object>',
983             c = d.createElement('div');
984
985         d.body.appendChild(c);
986         c.innerHTML = o;
987     }
988
989    /**
990     * @description Sets event handlers for XDomainRequest transactions.
991     *
992     * @method _evt
993     * @private
994     * @static
995     * @param {object} o - Transaction object generated by _create() in io-base.
996     * @param {object} c - configuration object for the transaction.
997     * @return void
998     */
999     function _evt(o, c) {
1000         o.c.onprogress = function() { _rS[o.id] = 3; };
1001         o.c.onload = function() {
1002             _rS[o.id] = 4;
1003             Y.io.xdrResponse(o, c, 'success');
1004         };
1005         o.c.onerror = function() {
1006             _rS[o.id] = 4;
1007             Y.io.xdrResponse(o, c, 'failure');
1008         };
1009         if (c.timeout) {
1010             o.c.ontimeout = function() {
1011                 _rS[o.id] = 4;
1012                 Y.io.xdrResponse(o, c, 'timeout');
1013             };
1014             o.c.timeout = c.timeout;
1015         }
1016     }
1017
1018    /**
1019     * @description Creates a response object for XDR transactions, for success
1020     * and failure cases.
1021     *
1022     * @method _data
1023     * @private
1024     * @static
1025     * @param {object} o - Transaction object generated by _create() in io-base.
1026     * @param {boolean} f - True if Flash was used as the transport.
1027     * @param {boolean} t - DataType value, as defined in the configuration.
1028     *
1029     * @return object
1030     */
1031     function _data(o, f, t) {
1032         var s, x;
1033
1034         if (!o.e) {
1035             s = f ? decodeURI(o.c.responseText) : o.c.responseText;
1036             x = t === 'xml' ?  Y.DataType.XML.parse(s) : null;
1037
1038             return { id: o.id, c: { responseText: s, responseXML: x } };
1039         }
1040         else {
1041             return { id: o.id, e: o.e };
1042         }
1043
1044     }
1045
1046    /**
1047     * @description Method for intiating an XDR transaction abort.
1048     *
1049     * @method _abort
1050     * @private
1051     * @static
1052     * @param {object} o - Transaction object generated by _create() in io-base.
1053     * @param {object} c - configuration object for the transaction.
1054     */
1055     function _abort(o, c) {
1056         return o.c.abort(o.id, c);
1057     }
1058
1059    /**
1060     * @description Method for determining if an XDR transaction has completed
1061     * and all data are received.
1062     *
1063     * @method _isInProgress.
1064     * @private
1065     * @static
1066     * @param {object} o - Transaction object generated by _create() in io-base.
1067     */
1068     function _isInProgress(o) {
1069         return ie ? _rS[o.id] !== 4 : o.c.isInProgress(o.id);
1070     }
1071
1072     Y.mix(Y.io, {
1073
1074        /**
1075         * @description Map of io transports.
1076         *
1077         * @property _transport
1078         * @private
1079         * @static
1080         * @type object
1081         */
1082         _transport: {},
1083
1084        /**
1085         * @description Method for accessing the transport's interface for making a
1086         * cross-domain transaction.
1087         *
1088         * @method xdr
1089         * @private
1090         * @static
1091         * @param {string} uri - qualified path to transaction resource.
1092         * @param {object} o - Transaction object generated by _create() in io-base.
1093         * @param {object} c - configuration object for the transaction.
1094         */
1095         xdr: function(uri, o, c) {
1096                         if (c.xdr.use === 'flash') {
1097                                 _cB[o.id] = {
1098                                         on: c.on,
1099                                         context: c.context,
1100                                         arguments: c.arguments
1101                                 };
1102                                 // These properties cannot be serialized across Flash's
1103                                 // ExternalInterface.  Doing so will result in exceptions.
1104                                 c.context = null;
1105                                 c.form = null;
1106
1107                                 w.setTimeout(function() {
1108                                         if (o.c && o.c.send) {
1109                                                 o.c.send(uri, c, o.id);
1110                                         }
1111                                         else {
1112                                                 Y.io.xdrResponse(o, c, 'transport error');
1113                                         }
1114                                 }, Y.io.xdr.delay);
1115                         }
1116                         else if (ie) {
1117                                 _evt(o, c);
1118                                 o.c.open(c.method || 'GET', uri);
1119                                 o.c.send(c.data);
1120                         }
1121                         else {
1122                                 o.c.send(uri, o, c);
1123                         }
1124
1125                         return {
1126                                 id: o.id,
1127                                 abort: function() {
1128                                         return o.c ? _abort(o, c) : false;
1129                                 },
1130                                 isInProgress: function() {
1131                                         return o.c ? _isInProgress(o.id) : false;
1132                                 }
1133                         };
1134         },
1135
1136        /**
1137         * @description Response controller for cross-domain requests when using the
1138         * Flash transport or IE8's XDomainRequest object.
1139         *
1140         * @method xdrResponse
1141         * @private
1142         * @static
1143         * @param {object} o - Transaction object generated by _create() in io-base.
1144         * @param {object} c - configuration object for the transaction.
1145         * @param {string} e - Event name
1146         * @return object
1147         */
1148         xdrResponse: function(o, c, e) {
1149             var cb,
1150                 m = ie ? _rS : _cB,
1151                 f = c.xdr.use === 'flash' ? true : false,
1152                 t = c.xdr.dataType;
1153                 c.on = c.on || {};
1154
1155             if (f) {
1156                 cb = _cB[o.id] ? _cB[o.id] : null;
1157                 if (cb) {
1158                     c.on = cb.on;
1159                     c.context = cb.context;
1160                     c.arguments = cb.arguments;
1161                 }
1162             }
1163
1164             switch (e) {
1165                 case 'start':
1166                     Y.io.start(o.id, c);
1167                     break;
1168                 case 'complete':
1169                     Y.io.complete(o, c);
1170                     break;
1171                 case 'success':
1172                     Y.io.success(t || f ? _data(o, f, t) : o, c);
1173                     delete m[o.id];
1174                     break;
1175                 case 'timeout':
1176                 case 'abort':
1177                                 case 'transport error':
1178                                         o.e = e;
1179                 case 'failure':
1180                     Y.io.failure(t || f ? _data(o, f, t) : o, c);
1181                     delete m[o.id];
1182                     break;
1183             }
1184         },
1185
1186        /**
1187         * @description Fires event "io:xdrReady"
1188         *
1189         * @method xdrReady
1190         * @private
1191         * @static
1192         * @param {number} id - transaction id
1193         * @param {object} c - configuration object for the transaction.
1194         *
1195         * @return void
1196         */
1197         xdrReady: function(id) {
1198                         Y.io.xdr.delay = 0;
1199             Y.fire(E_XDR_READY, id);
1200         },
1201
1202        /**
1203         * @description Method to initialize the desired transport.
1204         *
1205         * @method transport
1206         * @public
1207         * @static
1208         * @param {object} o - object of transport configurations.
1209         * @return void
1210         */
1211         transport: function(o) {
1212             var yid = o.yid || Y.id,
1213                                 oid = o.id || 'flash',
1214                                 src = Y.UA.ie ? o.src + '?d=' + new Date().valueOf().toString() : o.src;
1215
1216             if (oid === 'native' || oid === 'flash') {
1217
1218                                 _swf(src, yid);
1219                 this._transport.flash = d.getElementById('yuiIoSwf');
1220             }
1221             else if (oid) {
1222                 this._transport[o.id] = o.src;
1223             }
1224         }
1225     });
1226
1227    /**
1228         * @description Delay value to calling the Flash transport, in the
1229         * event io.swf has not finished loading.  Once the E_XDR_READY
1230     * event is fired, this value will be set to 0.
1231         *
1232         * @property delay
1233         * @public
1234         * @static
1235         * @type number
1236         */
1237         Y.io.xdr.delay = 50;
1238
1239
1240
1241 }, '3.3.0' ,{requires:['io-base','datatype-xml']});
1242
1243 YUI.add('io-upload-iframe', function(Y) {
1244
1245    /**
1246     * Extends the IO base class to enable file uploads, with HTML forms,
1247     * using an iframe as the transport medium.
1248     * @module io
1249     * @submodule io-upload-iframe
1250     */
1251
1252     var w = Y.config.win,
1253         d = Y.config.doc,
1254         _std = (d.documentMode && d.documentMode >= 8),
1255                 _d = decodeURIComponent;
1256    /**
1257     * @description Parses the POST data object and creates hidden form elements
1258     * for each key-value, and appends them to the HTML form object.
1259     * @method appendData
1260     * @private
1261     * @static
1262     * @param {object} f HTML form object.
1263     * @param {string} s The key-value POST data.
1264     * @return {array} e Array of created fields.
1265     */
1266     function _addData(f, s) {
1267         var o = [],
1268             m = s.split('='),
1269             i, l;
1270
1271         for (i = 0, l = m.length - 1; i < l; i++) {
1272             o[i] = d.createElement('input');
1273             o[i].type = 'hidden';
1274             o[i].name = _d(m[i].substring(m[i].lastIndexOf('&') + 1));
1275             o[i].value = (i + 1 === l) ? _d(m[i + 1]) : _d(m[i + 1].substring(0, (m[i + 1].lastIndexOf('&'))));
1276             f.appendChild(o[i]);
1277         }
1278
1279         return o;
1280     }
1281
1282    /**
1283     * @description Removes the custom fields created to pass additional POST
1284     * data, along with the HTML form fields.
1285     * @method f
1286     * @private
1287     * @static
1288     * @param {object} f HTML form object.
1289     * @param {object} o HTML form fields created from configuration.data.
1290     * @return {void}
1291     */
1292     function _removeData(f, o) {
1293         var i, l;
1294
1295         for (i = 0, l = o.length; i < l; i++) {
1296             f.removeChild(o[i]);
1297         }
1298     }
1299
1300    /**
1301     * @description Sets the appropriate attributes and values to the HTML
1302     * form, in preparation of a file upload transaction.
1303     * @method _setAttrs
1304     * @private
1305     * @static
1306     * @param {object} f HTML form object.
1307     * @param {object} id The Transaction ID.
1308     * @param {object} uri Qualified path to transaction resource.
1309     * @return {void}
1310     */
1311     function _setAttrs(f, id, uri) {
1312         f.setAttribute('action', uri);
1313         f.setAttribute('method', 'POST');
1314         f.setAttribute('target', 'ioupload' + id );
1315         f.setAttribute(Y.UA.ie && !_std ? 'encoding' : 'enctype', 'multipart/form-data');
1316     }
1317
1318    /**
1319     * @description Reset the HTML form attributes to their original values.
1320     * @method _resetAttrs
1321     * @private
1322     * @static
1323     * @param {object} f HTML form object.
1324     * @param {object} a Object of original attributes.
1325     * @return {void}
1326     */
1327     function _resetAttrs(f, a){
1328         var p;
1329
1330         for (p in a) {
1331             if (a.hasOwnProperty(p)) {
1332                 if (a[p]) {
1333                     f.setAttribute(p, f[p]);
1334                 }
1335                 else {
1336                     f.removeAttribute(p);
1337                 }
1338             }
1339         }
1340     }
1341
1342    /**
1343     * @description Starts timeout count if the configuration object
1344     * has a defined timeout property.
1345     *
1346     * @method _startTimeout
1347     * @private
1348     * @static
1349     * @param {object} o Transaction object generated by _create().
1350     * @param {object} c Configuration object passed to YUI.io().
1351     * @return {void}
1352     */
1353     function _startTimeout(o, c) {
1354         Y.io._timeout[o.id] = w.setTimeout(
1355             function() {
1356                 var r = { id: o.id, status: 'timeout' };
1357
1358                 Y.io.complete(r, c);
1359                 Y.io.end(r, c);
1360             }, c.timeout);
1361     }
1362
1363    /**
1364     * @description Clears the timeout interval started by _startTimeout().
1365     * @method _clearTimeout
1366     * @private
1367     * @static
1368     * @param {number} id - Transaction ID.
1369     * @return {void}
1370     */
1371     function _clearTimeout(id) {
1372         w.clearTimeout(Y.io._timeout[id]);
1373         delete Y.io._timeout[id];
1374     }
1375
1376    /**
1377     * @description
1378     * @method _destroy
1379     * @private
1380     * @static
1381     * @param {o} o The transaction object
1382     * @param {object} uri Qualified path to transaction resource.
1383     * @param {object} c Configuration object for the transaction.
1384     * @return {void}
1385     */
1386     function _destroy(id) {
1387         Y.Event.purgeElement('#ioupload' + id, false);
1388         Y.one('body').removeChild(Y.one('#ioupload' + id));
1389     }
1390
1391    /**
1392     * @description Bound to the iframe's Load event and processes
1393     * the response data.
1394     * @method _handle
1395     * @private
1396     * @static
1397     * @param {o} o The transaction object
1398     * @param {object} c Configuration object for the transaction.
1399     * @return {void}
1400     */
1401     function _handle(o, c) {
1402         var d = Y.one('#ioupload' + o.id).get('contentWindow.document'),
1403             b = d.one('body'),
1404             p;
1405
1406         if (c.timeout) {
1407             _clearTimeout(o.id);
1408         }
1409
1410         if (b) {
1411             // When a response Content-Type of "text/plain" is used, Firefox and Safari
1412             // will wrap the response string with <pre></pre>.
1413             p = b.one('pre:first-child');
1414             o.c.responseText = p ? p.get('text') : b.get('text');
1415         }
1416         else {
1417             o.c.responseXML = d._node;
1418         }
1419
1420         Y.io.complete(o, c);
1421         Y.io.end(o, c);
1422         // The transaction is complete, so call _destroy to remove
1423         // the event listener bound to the iframe transport, and then
1424         // destroy the iframe.
1425         w.setTimeout( function() { _destroy(o.id); }, 0);
1426     }
1427
1428    /**
1429     * @description Creates the iframe transported used in file upload
1430     * transactions, and binds the response event handler.
1431     *
1432     * @method _create
1433     * @private
1434     * @static
1435     * @param {object} o Transaction object generated by _create().
1436     * @param {object} c Configuration object passed to YUI.io().
1437     * @return {void}
1438     */
1439     function _create(o, c) {
1440         var i = Y.Node.create('<iframe id="ioupload' + o.id + '" name="ioupload' + o.id + '" />');
1441             i._node.style.position = 'absolute';
1442             i._node.style.top = '-1000px';
1443             i._node.style.left = '-1000px';
1444
1445         Y.one('body').appendChild(i);
1446         // Bind the onload handler to the iframe to detect the file upload response.
1447         Y.on("load", function() { _handle(o, c); }, '#ioupload' + o.id);
1448     }
1449
1450    /**
1451     * @description Uploads HTML form data, inclusive of files/attachments,
1452     * using the iframe created in _create to facilitate the transaction.
1453     * @method _upload
1454     * @private
1455     * @static
1456     * @param {o} o The transaction object
1457     * @param {object} uri Qualified path to transaction resource.
1458     * @param {object} c Configuration object for the transaction.
1459     * @return {void}
1460     */
1461     function _send(o, uri, c) {
1462         var f = (typeof c.form.id === 'string') ? d.getElementById(c.form.id) : c.form.id,
1463             fields,
1464             // Track original HTML form attribute values.
1465             attr = {
1466                 action: f.getAttribute('action'),
1467                 target: f.getAttribute('target')
1468             };
1469
1470         // Initialize the HTML form properties in case they are
1471         // not defined in the HTML form.
1472         _setAttrs(f, o.id, uri);
1473         if (c.data) {
1474             fields = _addData(f, c.data);
1475         }
1476
1477         // Start polling if a callback is present and the timeout
1478         // property has been defined.
1479         if (c.timeout) {
1480             _startTimeout(o, c);
1481         }
1482
1483         // Start file upload.
1484         f.submit();
1485         Y.io.start(o.id, c);
1486         if (c.data) {
1487             _removeData(f, fields);
1488         }
1489         // Restore HTML form attributes to their original values.
1490         _resetAttrs(f, attr);
1491
1492         return {
1493             id: o.id,
1494             abort: function() {
1495                 var r = { id: o.id, status: 'abort' };
1496
1497                 if (Y.one('#ioupload' + o.id)) {
1498                     _destroy(o.id);
1499                     Y.io.complete(r, c);
1500                     Y.io.end(r, c);
1501                 }
1502                 else {
1503                     return false;
1504                 }
1505             },
1506             isInProgress: function() {
1507                 return Y.one('#ioupload' + o.id) ? true : false;
1508             }
1509         };
1510     }
1511
1512     Y.mix(Y.io, {
1513         upload: function(o, uri, c) {
1514             _create(o, c);
1515             return _send(o, uri, c);
1516         }
1517     });
1518
1519
1520
1521 }, '3.3.0' ,{requires:['io-base','node-base']});
1522
1523 YUI.add('io-queue', function(Y) {
1524
1525    /**
1526     * Extends the IO base class to implement Queue for synchronous
1527     * transaction processing.
1528     * @module io
1529     * @submodule io-queue
1530     */
1531
1532    /**
1533     * @description Array of transactions queued for processing
1534     *
1535     * @property _yQ
1536     * @private
1537     * @static
1538     * @type Object
1539     */
1540     var _q = new Y.Queue(),
1541
1542     _activeId,
1543    /**
1544     * @description Property to determine whether the queue is set to
1545     * 1 (active) or 0 (inactive).  When inactive, transactions
1546     * will be stored in the queue until the queue is set to active.
1547     *
1548     * @property _qState
1549     * @private
1550     * @static
1551     * @type int
1552     */
1553     _qState = 1;
1554
1555    /**
1556     * @description Method Process the first transaction from the
1557     * queue in FIFO order.
1558     *
1559     * @method _shift
1560     * @private
1561     * @static
1562     * @return void
1563     */
1564     function _shift() {
1565         var o = _q.next();
1566
1567         _activeId = o.id;
1568         _qState = 0;
1569         Y.io(o.uri, o.cfg, o.id);
1570     }
1571
1572    /**
1573     * @description Method for promoting a transaction to the top of the queue.
1574     *
1575     * @method _unshift
1576     * @private
1577     * @static
1578     * @return void
1579     */
1580     function _unshift(o) {
1581         _q.promote(o);
1582     }
1583
1584    /**
1585     * @description Method for requesting a transaction, and queueing the
1586     * request before it is sent to the resource.
1587     *
1588     * @method _queue
1589     * @private
1590     * @static
1591     * @return Object
1592     */
1593     function _queue(uri, c) {
1594         var o = { uri: uri, id: Y.io._id(), cfg:c };
1595
1596         _q.add(o);
1597         if (_qState === 1) {
1598             _shift();
1599         }
1600
1601         return o;
1602     }
1603
1604     function _next(id) {
1605         _qState = 1;
1606         if (_activeId === id && _q.size() > 0) {
1607             _shift();
1608         }
1609     }
1610
1611    /**
1612     * @description Method for removing a specific, pending transaction from
1613     * the queue.
1614     *
1615     * @method _remove
1616     * @private
1617     * @static
1618     * @return void
1619     */
1620     function _remove(o) {
1621         _q.remove(o);
1622     }
1623
1624     function _start() {
1625         _qState = 1;
1626
1627         if (_q.size() > 0) {
1628             _shift();
1629         }
1630     }
1631
1632    /**
1633     * @description Method for setting queue processing to inactive.
1634     * Transaction requests to YUI.io.queue() will be stored in the queue, but
1635     * not processed until the queue is reset to "active".
1636     *
1637     * @method _stop
1638     * @private
1639     * @static
1640     * @return void
1641     */
1642     function _stop() {
1643         _qState = 0;
1644     }
1645
1646    /**
1647     * @description Method to query the current size of the queue.
1648     *
1649     * @method _size
1650     * @private
1651     * @static
1652     * @return int
1653     */
1654     function _size() {
1655         return _q.size();
1656     }
1657
1658    /**
1659     * @description Method to query the current size of the queue, or to
1660     * set a maximum queue size.  This is the interface for _size().
1661     *
1662     * @method size
1663     * @public
1664     * @static
1665     * @param {number} i - Specified maximum size of queue.
1666     * @return number
1667     */
1668     _queue.size = _size;
1669
1670    /**
1671     * @description Method for setting the queue to active. If there are
1672     * transactions pending in the queue, they will be processed from the
1673     * queue in FIFO order. This is the interface for _start().
1674     *
1675     * @method start
1676     * @public
1677     * @static
1678     * @return void
1679     */
1680     _queue.start = _start;
1681
1682    /**
1683     * @description Method for setting queue processing to inactive.
1684     * Transaction requests to YUI.io.queue() will be stored in the queue, but
1685     * not processed until the queue is restarted. This is the
1686     * interface for _stop().
1687     *
1688     * @method stop
1689     * @public
1690     * @static
1691     * @return void
1692     */
1693     _queue.stop = _stop;
1694
1695    /**
1696     * @description Method for promoting a transaction to the top of the queue.
1697     * This is the interface for _unshift().
1698     *
1699     * @method promote
1700     * @public
1701     * @static
1702     * @param {Object} o - Reference to queued transaction.
1703     * @return void
1704     */
1705     _queue.promote = _unshift;
1706
1707    /**
1708     * @description Method for removing a specific, pending transaction from
1709     * the queue. This is the interface for _remove().
1710     *
1711     * @method remove
1712     * @public
1713     * @static
1714     * @param {Object} o - Reference to queued transaction.
1715     * @return void
1716     */
1717     _queue.remove = _remove;
1718
1719     Y.on('io:complete', function(id) { _next(id); }, Y.io);
1720
1721     Y.mix(Y.io, {
1722         queue: _queue
1723     }, true);
1724
1725
1726
1727 }, '3.3.0' ,{requires:['io-base','queue-promote']});
1728
1729
1730
1731 YUI.add('io', function(Y){}, '3.3.0' ,{use:['io-base', 'io-form', 'io-xdr', 'io-upload-iframe', 'io-queue']});
1732