YUI.add('autocomplete-base', function (Y, NAME) {

/**

Provides automatic input completion or suggestions for text input fields and

textareas.

@module autocomplete

@main autocomplete

@since 3.3.0

**/

/**

`Y.Base` extension that provides core autocomplete logic (but no UI

implementation) for a text input field or textarea. Must be mixed into a

`Y.Base`-derived class to be useful.

@module autocomplete

@submodule autocomplete-base

**/

/**

Extension that provides core autocomplete logic (but no UI implementation) for a

text input field or textarea.

The `AutoCompleteBase` class provides events and attributes that abstract away

core autocomplete logic and configuration, but does not provide a widget

implementation or suggestion UI. For a prepackaged autocomplete widget, see

`AutoCompleteList`.

This extension cannot be instantiated directly, since it doesn't provide an

actual implementation. It's intended to be mixed into a `Y.Base`-based class or

widget.

`Y.Widget`-based example:

    YUI().use('autocomplete-base', 'widget', function (Y) {

        var MyAC = Y.Base.create('myAC', Y.Widget, [Y.AutoCompleteBase], {

            // Custom prototype methods and properties.

        }, {

            // Custom static methods and properties.

        });

        // Custom implementation code.

    });

`Y.Base`-based example:

    YUI().use('autocomplete-base', function (Y) {

        var MyAC = Y.Base.create('myAC', Y.Base, [Y.AutoCompleteBase], {

            initializer: function () {

                this._bindUIACBase();

                this._syncUIACBase();

            },

            // Custom prototype methods and properties.

        }, {

            // Custom static methods and properties.

        });

        // Custom implementation code.

    });

@class AutoCompleteBase

**/

var Escape  = Y.Escape,

    Lang    = Y.Lang,

    YArray  = Y.Array,

    YObject = Y.Object,

    isFunction = Lang.isFunction,

    isString   = Lang.isString,

    trim       = Lang.trim,

    INVALID_VALUE = Y.Attribute.INVALID_VALUE,

    _FUNCTION_VALIDATOR = '_functionValidator',

    _SOURCE_SUCCESS     = '_sourceSuccess',

    ALLOW_BROWSER_AC    = 'allowBrowserAutocomplete',

    INPUT_NODE          = 'inputNode',

    QUERY               = 'query',

    QUERY_DELIMITER     = 'queryDelimiter',

    REQUEST_TEMPLATE    = 'requestTemplate',

    RESULTS             = 'results',

    RESULT_LIST_LOCATOR = 'resultListLocator',

    VALUE               = 'value',

    VALUE_CHANGE        = 'valueChange',

    EVT_CLEAR   = 'clear',

    EVT_QUERY   = QUERY,

    EVT_RESULTS = RESULTS;

function AutoCompleteBase() {}

AutoCompleteBase.prototype = {

    // -- Lifecycle Methods ----------------------------------------------------

    initializer: function () {

        // AOP bindings.

        Y.before(this._bindUIACBase, this, 'bindUI');

        Y.before(this._syncUIACBase, this, 'syncUI');

        // -- Public Events ----------------------------------------------------

        /**

        Fires after the query has been completely cleared or no longer meets the

        minimum query length requirement.

        @event clear

        @param {String} prevVal Value of the query before it was cleared.

        @param {String} src Source of the event.

        @preventable _defClearFn

        **/

        this.publish(EVT_CLEAR, {

            defaultFn: this._defClearFn

        });

        /**

        Fires when the contents of the input field have changed and the input

        value meets the criteria necessary to generate an autocomplete query.

        @event query

        @param {String} inputValue Full contents of the text input field or

            textarea that generated the query.

        @param {String} query AutoComplete query. This is the string that will

            be used to request completion results. It may or may not be the same

            as `inputValue`.

        @param {String} src Source of the event.

        @preventable _defQueryFn

        **/

        this.publish(EVT_QUERY, {

            defaultFn: this._defQueryFn

        });

        /**

        Fires after query results are received from the source. If no source has

        been set, this event will not fire.

        @event results

        @param {Array|Object} data Raw, unfiltered result data (if available).

        @param {String} query Query that generated these results.

        @param {Object[]} results Array of filtered, formatted, and highlighted

            results. Each item in the array is an object with the following

            properties:

            @param {Node|HTMLElement|String} results.display Formatted result

                HTML suitable for display to the user. If no custom formatter is

                set, this will be an HTML-escaped version of the string in the

                `text` property.

            @param {String} [results.highlighted] Highlighted (but not

                formatted) result text. This property will only be set if a

                highlighter is in use.

            @param {Any} results.raw Raw, unformatted result in whatever form it

                was provided by the source.

            @param {String} results.text Plain text version of the result,

                suitable for being inserted into the value of a text input field

                or textarea when the result is selected by a user. This value is

                not HTML-escaped and should not be inserted into the page using

                `innerHTML` or `Node#setContent()`.

        @preventable _defResultsFn

        **/

        this.publish(EVT_RESULTS, {

            defaultFn: this._defResultsFn

        });

    },

    destructor: function () {

        this._acBaseEvents && this._acBaseEvents.detach();

        delete this._acBaseEvents;

        delete this._cache;

        delete this._inputNode;

        delete this._rawSource;

    },

    // -- Public Prototype Methods ---------------------------------------------

    /**

    Clears the result cache.

    @method clearCache

    @chainable

    @since 3.5.0

    **/

    clearCache: function () {

        this._cache && (this._cache = {});

        return this;

    },

    /**

    Sends a request to the configured source. If no source is configured, this

    method won't do anything.

    Usually there's no reason to call this method manually; it will be called

    automatically when user input causes a `query` event to be fired. The only

    time you'll need to call this method manually is if you want to force a

    request to be sent when no user input has occurred.

    @method sendRequest

    @param {String} [query] Query to send. If specified, the `query` attribute

        will be set to this query. If not specified, the current value of the

        `query` attribute will be used.

    @param {Function} [requestTemplate] Request template function. If not

        specified, the current value of the `requestTemplate` attribute will be

        used.

    @chainable

    **/

    sendRequest: function (query, requestTemplate) {

        var request,

            source = this.get('source');

        if (query || query === '') {

            this._set(QUERY, query);

        } else {

            query = this.get(QUERY) || '';

        }

        if (source) {

            if (!requestTemplate) {

                requestTemplate = this.get(REQUEST_TEMPLATE);

            }

            request = requestTemplate ?

                requestTemplate.call(this, query) : query;

            Y.log('sendRequest: ' + request, 'info', 'autocomplete-base');

            source.sendRequest({

                query  : query,

                request: request,

                callback: {

                    success: Y.bind(this._onResponse, this, query)

                }

            });

        }

        return this;

    },

    // -- Protected Lifecycle Methods ------------------------------------------

    /**

    Attaches event listeners and behaviors.

    @method _bindUIACBase

    @protected

    **/

    _bindUIACBase: function () {

        var inputNode  = this.get(INPUT_NODE),

            tokenInput = inputNode && inputNode.tokenInput;

        // If the inputNode has a node-tokeninput plugin attached, bind to the

        // plugin's inputNode instead.

        if (tokenInput) {

            inputNode = tokenInput.get(INPUT_NODE);

            this._set('tokenInput', tokenInput);

        }

        if (!inputNode) {

            Y.error('No inputNode specified.');

            return;

        }

        this._inputNode = inputNode;

        this._acBaseEvents = new Y.EventHandle([

            // This is the valueChange event on the inputNode, provided by the

            // event-valuechange module, not our own valueChange.

            inputNode.on(VALUE_CHANGE, this._onInputValueChange, this),

            inputNode.on('blur', this._onInputBlur, this),

            this.after(ALLOW_BROWSER_AC + 'Change', this._syncBrowserAutocomplete),

            this.after('sourceTypeChange', this._afterSourceTypeChange),

            this.after(VALUE_CHANGE, this._afterValueChange)

        ]);

    },

    /**

    Synchronizes the UI state of the `inputNode`.

    @method _syncUIACBase

    @protected

    **/

    _syncUIACBase: function () {

        this._syncBrowserAutocomplete();

        this.set(VALUE, this.get(INPUT_NODE).get(VALUE));

    },

    // -- Protected Prototype Methods ------------------------------------------

    /**

    Creates a DataSource-like object that simply returns the specified array as

    a response. See the `source` attribute for more details.

    @method _createArraySource

    @param {Array} source

    @return {Object} DataSource-like object.

    @protected

    **/

    _createArraySource: function (source) {

        var that = this;

        return {

            type: 'array',

            sendRequest: function (request) {

                that[_SOURCE_SUCCESS](source.concat(), request);

            }

        };

    },

    /**

    Creates a DataSource-like object that passes the query to a custom-defined

    function, which is expected to call the provided callback with an array of

    results. See the `source` attribute for more details.

    @method _createFunctionSource

    @param {Function} source Function that accepts a query and a callback as

      parameters, and calls the callback with an array of results.

    @return {Object} DataSource-like object.

    @protected

    **/

    _createFunctionSource: function (source) {

        var that = this;

        return {

            type: 'function',

            sendRequest: function (request) {

                var value;

                function afterResults(results) {

                    that[_SOURCE_SUCCESS](results || [], request);

                }

                // Allow both synchronous and asynchronous functions. If we get

                // a truthy return value, assume the function is synchronous.

                if ((value = source(request.query, afterResults))) {

                    afterResults(value);

                }

            }

        };

    },

    /**

    Creates a DataSource-like object that looks up queries as properties on the

    specified object, and returns the found value (if any) as a response. See

    the `source` attribute for more details.

    @method _createObjectSource

    @param {Object} source

    @return {Object} DataSource-like object.

    @protected

    **/

    _createObjectSource: function (source) {

        var that = this;

        return {

            type: 'object',

            sendRequest: function (request) {

                var query = request.query;

                that[_SOURCE_SUCCESS](

                    YObject.owns(source, query) ? source[query] : [],

                    request

                );

            }

        };

    },

    /**

    Returns `true` if _value_ is either a function or `null`.

    @method _functionValidator

    @param {Function|null} value Value to validate.

    @protected

    **/

    _functionValidator: function (value) {

        return value === null || isFunction(value);

    },

    /**

    Faster and safer alternative to `Y.Object.getValue()`. Doesn't bother

    casting the path to an array (since we already know it's an array) and

    doesn't throw an error if a value in the middle of the object hierarchy is

    neither `undefined` nor an object.

    @method _getObjectValue

    @param {Object} obj

    @param {Array} path

    @return {Any} Located value, or `undefined` if the value was

        not found at the specified path.

    @protected

    **/

    _getObjectValue: function (obj, path) {

        if (!obj) {

            return;

        }

        for (var i = 0, len = path.length; obj && i < len; i++) {

            obj = obj[path[i]];

        }

        return obj;

    },

    /**

    Parses result responses, performs filtering and highlighting, and fires the

    `results` event.

    @method _parseResponse

    @param {String} query Query that generated these results.

    @param {Object} response Response containing results.

    @param {Object} data Raw response data.

    @protected

    **/

    _parseResponse: function (query, response, data) {

        var facade = {

                data   : data,

                query  : query,

                results: []

            },

            listLocator = this.get(RESULT_LIST_LOCATOR),

            results     = [],

            unfiltered  = response && response.results,

            filters,

            formatted,

            formatter,

            highlighted,