https://www.cimmyt.org/wp-includes/js/jquery/ui/autocomplete.js?ver=1.13.3

40
41
42$.widget( "ui.autocomplete", {
43	version: "1.13.3",
44	defaultElement: "<input>",
45	options: {
46		appendTo: null,
47		autoFocus: false,
48		delay: 300,
49		minLength: 1,
50		position: {
51			my: "left top",
52			at: "left bottom",
53			collision: "none"
54		},
55		source: null,
56
57		// Callbacks
58		change: null,
59		close: null,
60		focus: null,
61		open: null,
62		response: null,
63		search: null,
64		select: null
65	},
66
67	requestIndex: 0,
68	pending: 0,
69	liveRegionTimer: null,
70
71	_create: function() {
72
73		// Some browsers only repeat keydown events, not keypress events,
74		// so we use the suppressKeyPress flag to determine if we've already
75		// handled the keydown event. #7269
76		// Unfortunately the code for & in keypress is the same as the up arrow,
77		// so we use the suppressKeyPressRepeat flag to avoid handling keypress
78		// events when we know the keydown event was used to modify the
79		// search term. #7799
80		var suppressKeyPress, suppressKeyPressRepeat, suppressInput,
81			nodeName = this.element[ 0 ].nodeName.toLowerCase(),
82			isTextarea = nodeName === "textarea",
83			isInput = nodeName === "input";
84
85		// Textareas are always multi-line
86		// Inputs are always single-line, even if inside a contentEditable element
87		// IE also treats inputs as contentEditable
88		// All other element types are determined by whether or not they're contentEditable
89		this.isMultiLine = isTextarea || !isInput && this._isContentEditable( this.element );
90
91		this.valueMethod = this.element[ isTextarea || isInput ? "val" : "text" ];
92		this.isNewMenu = true;
93
94		this._addClass( "ui-autocomplete-input" );
95		this.element.attr( "autocomplete", "off" );
96
97		this._on( this.element, {
98			keydown: function( event ) {
99				if ( this.element.prop( "readOnly" ) ) {
100					suppressKeyPress = true;
101					suppressInput = true;
102					suppressKeyPressRepeat = true;
103					return;
104				}
105
106				suppressKeyPress = false;
107				suppressInput = false;
108				suppressKeyPressRepeat = false;
109				var keyCode = $.ui.keyCode;
110				switch ( event.keyCode ) {
111				case keyCode.PAGE_UP:
112					suppressKeyPress = true;
113					this._move( "previousPage", event );
114					break;
115				case keyCode.PAGE_DOWN:
116					suppressKeyPress = true;
117					this._move( "nextPage", event );
118					break;
119				case keyCode.UP:
120					suppressKeyPress = true;
121					this._keyEvent( "previous", event );
122					break;
123				case keyCode.DOWN:
124					suppressKeyPress = true;
125					this._keyEvent( "next", event );
126					break;
127				case keyCode.ENTER:
128
129					// when menu is open and has focus
130					if ( this.menu.active ) {
131
132						// #6055 - Opera still allows the keypress to occur
133						// which causes forms to submit
134						suppressKeyPress = true;
135						event.preventDefault();
136						this.menu.select( event );
137					}
138					break;
139				case keyCode.TAB:
140					if ( this.menu.active ) {
141						this.menu.select( event );
142					}
143					break;
144				case keyCode.ESCAPE:
145					if ( this.menu.element.is( ":visible" ) ) {
146						if ( !this.isMultiLine ) {
147							this._value( this.term );
148						}
149						this.close( event );
150
151						// Different browsers have different default behavior for escape
152						// Single press can mean undo or clear
153						// Double press in IE means clear the whole form
154						event.preventDefault();
155					}
156					break;
157				default:
158					suppressKeyPressRepeat = true;
159
160					// search timeout should be triggered before the input value is changed
161					this._searchTimeout( event );
162					break;
163				}
164			},
165			keypress: function( event ) {
166				if ( suppressKeyPress ) {
167					suppressKeyPress = false;
168					if ( !this.isMultiLine || this.menu.element.is( ":visible" ) ) {
169						event.preventDefault();
170					}
171					return;
172				}
173				if ( suppressKeyPressRepeat ) {
174					return;
175				}
176
177				// Replicate some key handlers to allow them to repeat in Firefox and Opera
178				var keyCode = $.ui.keyCode;
179				switch ( event.keyCode ) {
180				case keyCode.PAGE_UP:
181					this._move( "previousPage", event );
182					break;
183				case keyCode.PAGE_DOWN:
184					this._move( "nextPage", event );
185					break;
186				case keyCode.UP:
187					this._keyEvent( "previous", event );
188					break;
189				case keyCode.DOWN:
190					this._keyEvent( "next", event );
191					break;
192				}
193			},
194			input: function( event ) {
195				if ( suppressInput ) {
196					suppressInput = false;
197					event.preventDefault();
198					return;
199				}
200				this._searchTimeout( event );
201			},
202			focus: function() {
203				this.selectedItem = null;
204				this.previous = this._value();
205			},
206			blur: function( event ) {
207				clearTimeout( this.searching );
208				this.close( event );
209				this._change( event );
210			}
211		} );
212
213		this._initSource();
214		this.menu = $( "<ul>" )
215			.appendTo( this._appendTo() )
216			.menu( {
217
218				// disable ARIA support, the live region takes care of that
219				role: null
220			} )
221			.hide()
222
223			// Support: IE 11 only, Edge <= 14
224			// For other browsers, we preventDefault() on the mousedown event
225			// to keep the dropdown from taking focus from the input. This doesn't
226			// work for IE/Edge, causing problems with selection and scrolling (#9638)
227			// Happily, IE and Edge support an "unselectable" attribute that
228			// prevents an element from receiving focus, exactly what we want here.
229			.attr( {
230				"unselectable": "on"
231			} )
232			.menu( "instance" );
233
234		this._addClass( this.menu.element, "ui-autocomplete", "ui-front" );
235		this._on( this.menu.element, {
236			mousedown: function( event ) {
237
238				// Prevent moving focus out of the text field
239				event.preventDefault();
240			},
241			menufocus: function( event, ui ) {
242				var label, item;
243
244				// support: Firefox
245				// Prevent accidental activation of menu items in Firefox (#7024 #9118)
246				if ( this.isNewMenu ) {
247					this.isNewMenu = false;
248					if ( event.originalEvent && /^mouse/.test( event.originalEvent.type ) ) {
249						this.menu.blur();
250
251						this.document.one( "mousemove", function() {
252							$( event.target ).trigger( event.originalEvent );
253						} );
254
255						return;
256					}
257				}
258
259				item = ui.item.data( "ui-autocomplete-item" );
260				if ( false !== this._trigger( "focus", event, { item: item } ) ) {
261
262					// use value to match what will end up in the input, if it was a key event
263					if ( event.originalEvent && /^key/.test( event.originalEvent.type ) ) {
264						this._value( item.value );
265					}
266				}
267
268				// Announce the value in the liveRegion
269				label = ui.item.attr( "aria-label" ) || item.value;
270				if ( label && String.prototype.trim.call( label ).length ) {
271					clearTimeout( this.liveRegionTimer );
272					this.liveRegionTimer = this._delay( function() {
273						this.liveRegion.html( $( "<div>" ).text( label ) );
274					}, 100 );
275				}
276			},
277			menuselect: function( event, ui ) {
278				var item = ui.item.data( "ui-autocomplete-item" ),
279					previous = this.previous;
280
281				// Only trigger when focus was lost (click on menu)
282				if ( this.element[ 0 ] !== $.ui.safeActiveElement( this.document[ 0 ] ) ) {
283					this.element.trigger( "focus" );
284					this.previous = previous;
285
286					// #6109 - IE triggers two focus events and the second
287					// is asynchronous, so we need to reset the previous
288					// term synchronously and asynchronously :-(
289					this._delay( function() {
290						this.previous = previous;
291						this.selectedItem = item;
292					} );
293				}
294
295				if ( false !== this._trigger( "select", event, { item: item } ) ) {
296					this._value( item.value );
297				}
298
299				// reset the term after the select event
300				// this allows custom select handling to work properly
301				this.term = this._value();
302
303				this.close( event );
304				this.selectedItem = item;
305			}
306		} );
307
308		this.liveRegion = $( "<div>", {
309			role: "status",
310			"aria-live": "assertive",
311			"aria-relevant": "additions"
312		} )
313			.appendTo( this.document[ 0 ].body );
314
315		this._addClass( this.liveRegion, null, "ui-helper-hidden-accessible" );
316
317		// Turning off autocomplete prevents the browser from remembering the
318		// value when navigating through history, so we re-enable autocomplete
319		// if the page is unloaded before the widget is destroyed. #7790
320		this._on( this.window, {
321			beforeunload: function() {
322				this.element.removeAttr( "autocomplete" );
323			}
324		} );
325	},
326
327	_destroy: function() {
328		clearTimeout( this.searching );
329		this.element.removeAttr( "autocomplete" );
330		this.menu.element.remove();
331		this.liveRegion.remove();
332	},
333
334	_setOption: function( key, value ) {
335		this._super( key, value );
336		if ( key === "source" ) {
337			this._initSource();
338		}
339		if ( key === "appendTo" ) {
340			this.menu.element.appendTo( this._appendTo() );
341		}
342		if ( key === "disabled" && value && this.xhr ) {
343			this.xhr.abort();
344		}
345	},
346
347	_isEventTargetInWidget: function( event ) {
348		var menuElement = this.menu.element[ 0 ];
349
350		return event.target === this.element[ 0 ] ||
351			event.target === menuElement ||
352			$.contains( menuElement, event.target );
353	},
354
355	_closeOnClickOutside: function( event ) {
356		if ( !this._isEventTargetInWidget( event ) ) {
357			this.close();
358		}
359	},
360
361	_appendTo: function() {
362		var element = this.options.appendTo;
363
364		if ( element ) {
365			element = element.jquery || element.nodeType ?
366				$( element ) :
367				this.document.find( element ).eq( 0 );
368		}
369
370		if ( !element || !element[ 0 ] ) {
371			element = this.element.closest( ".ui-front, dialog" );
372		}
373
374		if ( !element.length ) {
375			element = this.document[ 0 ].body;
376		}
377
378		return element;
379	},
380
381	_initSource: function() {
382		var array, url,
383			that = this;
384		if ( Array.isArray( this.options.source ) ) {
385			array = this.options.source;
386			this.source = function( request, response ) {
387				response( $.ui.autocomplete.filter( array, request.term ) );
388			};
389		} else if ( typeof this.options.source === "string" ) {
390			url = this.options.source;
391			this.source = function( request, response ) {
392				if ( that.xhr ) {
393					that.xhr.abort();
394				}
395				that.xhr = $.ajax( {
396					url: url,
397					data: request,
398					dataType: "json",
399					success: function( data ) {
400						response( data );
401					},
402					error: function() {
403						response( [] );
404					}
405				} );
406			};
407		} else {
408			this.source = this.options.source;
409		}
410	},
411
412	_searchTimeout: function( event ) {
413		clearTimeout( this.searching );
414		this.searching = this._delay( function() {
415
416			// Search if the value has changed, or if the user retypes the same value (see #7434)
417			var equalValues = this.term === this._value(),
418				menuVisible = this.menu.element.is( ":visible" ),
419				modifierKey = event.altKey || event.ctrlKey || event.metaKey || event.shiftKey;
420
421			if ( !equalValues || ( equalValues && !menuVisible && !modifierKey ) ) {
422				this.selectedItem = null;
423				this.search( null, event );
424			}
425		}, this.options.delay );
426	},
427
428	search: function( value, event ) {
429		value = value != null ? value : this._value();
430
431		// Always save the actual value, not the one passed as an argument
432		this.term = this._value();
433
434		if ( value.length < this.options.minLength ) {
435			return this.close( event );
436		}
437
438		if ( this._trigger( "search", event ) === false ) {
439			return;
440		}
441
442		return this._search( value );
443	},
444
445	_search: function( value ) {
446		this.pending++;
447		this._addClass( "ui-autocomplete-loading" );
448		this.cancelSearch = false;
449
450		this.source( { term: value }, this._response() );
451	},
452
453	_response: function() {
454		var index = ++this.requestIndex;
455
456		return function( content ) {
457			if ( index === this.requestIndex ) {
458				this.__response( content );
459			}
460
461			this.pending--;
462			if ( !this.pending ) {
463				this._removeClass( "ui-autocomplete-loading" );
464			}
465		}.bind( this );
466	},
467
468	__response: function( content ) {
469		if ( content ) {
470			content = this._normalize( content );
471		}
472		this._trigger( "response", null, { content: content } );
473		if ( !this.options.disabled && content && content.length && !this.cancelSearch ) {
474			this._suggest( content );
475			this._trigger( "open" );
476		} else {
477
478			// use ._close() instead of .close() so we don't cancel future searches
479			this._close();
480		}
481	},
482
483	close: function( event ) {
484		this.cancelSearch = true;
485		this._close( event );
486	},
487
488	_close: function( event ) {
489
490		// Remove the handler that closes the menu on outside clicks
491		this._off( this.document, "mousedown" );
492
493		if ( this.menu.element.is( ":visible" ) ) {
494			this.menu.element.hide();
495			this.menu.blur();
496			this.isNewMenu = true;
497			this._trigger( "close", event );
498		}
499	},
500
501	_change: function( event ) {
502		if ( this.previous !== this._value() ) {
503			this._trigger( "change", event, { item: this.selectedItem } );
504		}
505	},
506
507	_normalize: function( items ) {
508
509		// assume all items have the right format when the first item is complete
510		if ( items.length && items[ 0 ].label && items[ 0 ].value ) {
511			return items;
512		}
513		return $.map( items, function( item ) {
514			if ( typeof item === "string" ) {
515				return {
516					label: item,
517					value: item
518				};
519			}
520			return $.extend( {}, item, {
521				label: item.label || item.value,
522				value: item.value || item.label
523			} );
524		} );
525	},
526
527	_suggest: function( items ) {
528		var ul = this.menu.element.empty();
529		this._renderMenu( ul, items );
530		this.isNewMenu = true;
531		this.menu.refresh();
532
533		// Size and position menu
534		ul.show();
535		this._resizeMenu();
536		ul.position( $.extend( {
537			of: this.element
538		}, this.options.position ) );
539
540		if ( this.options.autoFocus ) {
541			this.menu.next();
542		}
543
544		// Listen for interactions outside of the widget (#6642)
545		this._on( this.document, {
546			mousedown: "_closeOnClickOutside"
547		} );
548	},
549
550	_resizeMenu: function() {
551		var ul = this.menu.element;
552		ul.outerWidth( Math.max(
553
554			// Firefox wraps long text (possibly a rounding bug)
555			// so we add 1px to avoid the wrapping (#7513)
556			ul.width( "" ).outerWidth() + 1,
557			this.element.outerWidth()
558		) );
559	},
560
561	_renderMenu: function( ul, items ) {
562		var that = this;
563		$.each( items, function( index, item ) {
564			that._renderItemData( ul, item );
565		} );
566	},
567
568	_renderItemData: function( ul, item ) {
569		return this._renderItem( ul, item ).data( "ui-autocomplete-item", item );
570	},
571
572	_renderItem: function( ul, item ) {
573		return $( "<li>" )
574			.append( $( "<div>" ).text( item.label ) )
575			.appendTo( ul );
576	},
577
578	_move: function( direction, event ) {
579		if ( !this.menu.element.is( ":visible" ) ) {
580			this.search( null, event );
581			return;
582		}
583		if ( this.menu.isFirstItem() && /^previous/.test( direction ) ||
584				this.menu.isLastItem() && /^next/.test( direction ) ) {
585
586			if ( !this.isMultiLine ) {
587				this._value( this.term );
588			}
589
590			this.menu.blur();
591			return;
592		}
593		this.menu[ direction ]( event );
594	},
595
596	widget: function() {
597		return this.menu.element;
598	},
599
600	_value: function() {
601		return this.valueMethod.apply( this.element, arguments );
602	},
603
604	_keyEvent: function( keyEvent, event ) {
605		if ( !this.isMultiLine || this.menu.element.is( ":visible" ) ) {
606			this._move( keyEvent, event );
607
608			// Prevents moving cursor to beginning/end of the text field in some browsers
609			event.preventDefault();
610		}
611	},
612
613	// Support: Chrome <=50
614	// We should be able to just use this.element.prop( "isContentEditable" )
615	// but hidden elements always report false in Chrome.
616	// https://code.google.com/p/chromium/issues/detail?id=313082
617	_isContentEditable: function( element ) {
618		if ( !element.length ) {
619			return false;
620		}
621
622		var editable = element.prop( "contentEditable" );
623
624		if ( editable === "inherit" ) {
625			return this._isContentEditable( element.parent() );
626		}
627
628		return editable === "true";
629	}
630} );
631
632$.extend( $.ui.autocomplete, {
633	escapeRegex: function( value ) {
634		return value.replace( /[\-\[\]{}()*+?.,\\\^$|#\s]/g, "\\$&" );
635	},
636	filter: function( array, term ) {
637		var matcher = new RegExp( $.ui.autocomplete.escapeRegex( term ), "i" );
638		return $.grep( array, function( value ) {
639			return matcher.test( value.label || value.value || value );
640		} );
641	}
642} );
643
644// Live region extension, adding a `messages` option
645// NOTE: This is an experimental API. We are still investigating
646// a full solution for string manipulation and internationalization.
647$.widget( "ui.autocomplete", $.ui.autocomplete, {
648	options: {
649		messages: {
650			noResults: "No search results.",
651			results: function( amount ) {
652				return amount + ( amount > 1 ? " results are" : " result is" ) +
653					" available, use up and down arrow keys to navigate.";
654			}
655		}
656	},
657
658	__response: function( content ) {
659		var message;
660		this._superApply( arguments );
661		if ( this.options.disabled || this.cancelSearch ) {
662			return;
663		}
664		if ( content && content.length ) {
665			message = this.options.messages.results( content.length );
666		} else {
667			message = this.options.messages.noResults;
668		}
669		clearTimeout( this.liveRegionTimer );
670		this.liveRegionTimer = this._delay( function() {
671			this.liveRegion.html( $( "<div>" ).text( message ) );
672		}, 100 );
673	}
674} );
675