@canonical/yui 3.18.2-pre

package/build/array-extras/array-extras.js

@@ -0,0 +1,400 @@
+YUI.add('array-extras', function (Y, NAME) {
+
+/**
+Adds additional utility methods to the `Y.Array` class.
+
+@module collection
+@submodule array-extras
+**/
+
+var A          = Y.Array,
+    L          = Y.Lang,
+    ArrayProto = Array.prototype;
+
+/**
+Returns the index of the last item in the array that contains the specified
+value, or `-1` if the value isn't found.
+
+@method lastIndexOf
+@param {Array} a Array to search in.
+@param {Any} val Value to search for.
+@param {Number} [fromIndex] Index at which to start searching backwards.
+  Defaults to the array's length - 1. If negative, it will be taken as an offset
+  from the end of the array. If the calculated index is less than 0, the array
+  will not be searched and `-1` will be returned.
+@return {Number} Index of the item that contains the value, or `-1` if not
+  found.
+@static
+@for Array
+**/
+A.lastIndexOf = L._isNative(ArrayProto.lastIndexOf) ?
+    function(a, val, fromIndex) {
+        // An undefined fromIndex is still considered a value by some (all?)
+        // native implementations, so we can't pass it unless it's actually
+        // specified.
+        return fromIndex || fromIndex === 0 ? a.lastIndexOf(val, fromIndex) :
+                a.lastIndexOf(val);
+    } :
+    function(a, val, fromIndex) {
+        var len = a.length,
+            i   = len - 1;
+
+        if (fromIndex || fromIndex === 0) {
+            i = Math.min(fromIndex < 0 ? len + fromIndex : fromIndex, len);
+        }
+
+        if (i > -1 && len > 0) {
+            for (; i > -1; --i) {
+                if (i in a && a[i] === val) {
+                    return i;
+                }
+            }
+        }
+
+        return -1;
+    };
+
+/**
+Returns a copy of the input array with duplicate items removed.
+
+Note: If the input array only contains strings, the `Y.Array.dedupe()` method is
+a much faster alternative.
+
+@method unique
+@param {Array} array Array to dedupe.
+@param {Function} [testFn] Custom function to use to test the equality of two
+    values. A truthy return value indicates that the values are equal. A falsy
+    return value indicates that the values are not equal.
+
+    @param {Any} testFn.a First value to compare.
+    @param {Any} testFn.b Second value to compare.
+    @param {Number} testFn.index Index of the current item in the original
+        array.
+    @param {Array} testFn.array The original array.
+    @return {Boolean} _true_ if the items are equal, _false_ otherwise.
+
+@return {Array} Copy of the input array with duplicate items removed.
+@static
+**/
+A.unique = function (array, testFn) {
+    var i       = 0,
+        len     = array.length,
+        results = [],
+        j, result, resultLen, value;
+
+    // Note the label here. It's used to jump out of the inner loop when a value
+    // is not unique.
+    outerLoop: for (; i < len; i++) {
+        value = array[i];
+
+        // For each value in the input array, iterate through the result array
+        // and check for uniqueness against each result value.
+        for (j = 0, resultLen = results.length; j < resultLen; j++) {
+            result = results[j];
+
+            // If the test function returns true or there's no test function and
+            // the value equals the current result item, stop iterating over the
+            // results and continue to the next value in the input array.
+            if (testFn) {
+                if (testFn.call(array, value, result, i, array)) {
+                    continue outerLoop;
+                }
+            } else if (value === result) {
+                continue outerLoop;
+            }
+        }
+
+        // If we get this far, that means the current value is not already in
+        // the result array, so add it.
+        results.push(value);
+    }
+
+    return results;
+};
+
+/**
+Executes the supplied function on each item in the array. Returns a new array
+containing the items for which the supplied function returned a truthy value.
+
+@method filter
+@param {Array} a Array to filter.
+@param {Function} f Function to execute on each item.
+@param {Object} [o] Optional context object.
+@return {Array} Array of items for which the supplied function returned a
+  truthy value (empty if it never returned a truthy value).
+@static
+*/
+A.filter = L._isNative(ArrayProto.filter) ?
+    function(a, f, o) {
+        return ArrayProto.filter.call(a, f, o);
+    } :
+    function(a, f, o) {
+        var i       = 0,
+            len     = a.length,
+            results = [],
+            item;
+
+        for (; i < len; ++i) {
+            if (i in a) {
+                item = a[i];
+
+                if (f.call(o, item, i, a)) {
+                    results.push(item);
+                }
+            }
+        }
+
+        return results;
+    };
+
+/**
+The inverse of `Array.filter()`. Executes the supplied function on each item.
+Returns a new array containing the items for which the supplied function
+returned `false`.
+
+@method reject
+@param {Array} a the array to iterate.
+@param {Function} f the function to execute on each item.
+@param {object} [o] Optional context object.
+@return {Array} The items for which the supplied function returned `false`.
+@static
+*/
+A.reject = function(a, f, o) {
+    return A.filter(a, function(item, i, a) {
+        return !f.call(o, item, i, a);
+    });
+};
+
+/**
+Executes the supplied function on each item in the array. Iteration stops if the
+supplied function does not return a truthy value.
+
+@method every
+@param {Array} a the array to iterate.
+@param {Function} f the function to execute on each item.
+@param {Object} [o] Optional context object.
+@return {Boolean} `true` if every item in the array returns `true` from the
+  supplied function, `false` otherwise.
+@static
+*/
+A.every = L._isNative(ArrayProto.every) ?
+    function(a, f, o) {
+        return ArrayProto.every.call(a, f, o);
+    } :
+    function(a, f, o) {
+        for (var i = 0, l = a.length; i < l; ++i) {
+            if (i in a && !f.call(o, a[i], i, a)) {
+                return false;
+            }
+        }
+
+        return true;
+    };
+
+/**
+Executes the supplied function on each item in the array and returns a new array
+containing all the values returned by the supplied function.
+
+@example
+
+    // Convert an array of numbers into an array of strings.
+    Y.Array.map([1, 2, 3, 4], function (item) {
+      return '' + item;
+    });
+    // => ['1', '2', '3', '4']
+
+@method map
+@param {Array} a the array to iterate.
+@param {Function} f the function to execute on each item.
+@param {object} [o] Optional context object.
+@return {Array} A new array containing the return value of the supplied function
+  for each item in the original array.
+@static
+*/
+A.map = L._isNative(ArrayProto.map) ?
+    function(a, f, o) {
+        return ArrayProto.map.call(a, f, o);
+    } :
+    function(a, f, o) {
+        var i       = 0,
+            len     = a.length,
+            results = ArrayProto.concat.call(a);
+
+        for (; i < len; ++i) {
+            if (i in a) {
+                results[i] = f.call(o, a[i], i, a);
+            }
+        }
+
+        return results;
+    };
+
+
+/**
+Executes the supplied function on each item in the array, "folding" the array
+into a single value.
+
+@method reduce
+@param {Array} a Array to iterate.
+@param {Any} init Initial value to start with.
+@param {Function} f Function to execute on each item. This function should
+  update and return the value of the computation. It will receive the following
+  arguments:
+    @param {Any} f.previousValue Value returned from the previous iteration,
+      or the initial value if this is the first iteration.
+    @param {Any} f.currentValue Value of the current item being iterated.
+    @param {Number} f.index Index of the current item.
+    @param {Array} f.array Array being iterated.
+@param {Object} [o] Optional context object.
+@return {Any} Final result from iteratively applying the given function to each
+  element in the array.
+@static
+*/
+A.reduce = L._isNative(ArrayProto.reduce) ?
+    function(a, init, f, o) {
+        // ES5 Array.reduce doesn't support a thisObject, so we need to
+        // implement it manually.
+        return ArrayProto.reduce.call(a, function(init, item, i, a) {
+            return f.call(o, init, item, i, a);
+        }, init);
+    } :
+    function(a, init, f, o) {
+        var i      = 0,
+            len    = a.length,
+            result = init;
+
+        for (; i < len; ++i) {
+            if (i in a) {
+                result = f.call(o, result, a[i], i, a);
+            }
+        }
+
+        return result;
+    };
+
+/**
+Executes the supplied function on each item in the array, searching for the
+first item that matches the supplied function.
+
+@method find
+@param {Array} a the array to search.
+@param {Function} f the function to execute on each item. Iteration is stopped
+  as soon as this function returns `true`.
+@param {Object} [o] Optional context object.
+@return {Object} the first item that the supplied function returns `true` for,
+  or `null` if it never returns `true`.
+@static
+*/
+A.find = function(a, f, o) {
+    for (var i = 0, l = a.length; i < l; i++) {
+        if (i in a && f.call(o, a[i], i, a)) {
+            return a[i];
+        }
+    }
+    return null;
+};
+
+/**
+Iterates over an array, returning a new array of all the elements that match the
+supplied regular expression.
+
+@method grep
+@param {Array} a Array to iterate over.
+@param {RegExp} pattern Regular expression to test against each item.
+@return {Array} All the items in the array that produce a match against the
+  supplied regular expression. If no items match, an empty array is returned.
+@static
+*/
+A.grep = function(a, pattern) {
+    return A.filter(a, function(item, index) {
+        return pattern.test(item);
+    });
+};
+
+/**
+Partitions an array into two new arrays, one with the items for which the
+supplied function returns `true`, and one with the items for which the function
+returns `false`.
+
+@method partition
+@param {Array} a Array to iterate over.
+@param {Function} f Function to execute for each item in the array. It will
+  receive the following arguments:
+    @param {Any} f.item Current item.
+    @param {Number} f.index Index of the current item.
+    @param {Array} f.array The array being iterated.
+@param {Object} [o] Optional execution context.
+@return {Object} An object with two properties: `matches` and `rejects`. Each is
+  an array containing the items that were selected or rejected by the test
+  function (or an empty array if none).
+@static
+*/
+A.partition = function(a, f, o) {
+    var results = {
+        matches: [],
+        rejects: []
+    };
+
+    A.each(a, function(item, index) {
+        var set = f.call(o, item, index, a) ? results.matches : results.rejects;
+        set.push(item);
+    });
+
+    return results;
+};
+
+/**
+Creates an array of arrays by pairing the corresponding elements of two arrays
+together into a new array.
+
+@method zip
+@param {Array} a Array to iterate over.
+@param {Array} a2 Another array whose values will be paired with values of the
+  first array.
+@return {Array} An array of arrays formed by pairing each element of the first
+  array with an item in the second array having the corresponding index.
+@static
+*/
+A.zip = function(a, a2) {
+    var results = [];
+    A.each(a, function(item, index) {
+        results.push([item, a2[index]]);
+    });
+    return results;
+};
+
+/**
+Flattens an array of nested arrays at any abitrary depth into a single, flat
+array.
+
+@method flatten
+@param {Array} a Array with nested arrays to flatten.
+@return {Array} An array whose nested arrays have been flattened.
+@static
+@since 3.7.0
+**/
+A.flatten = function(a) {
+    var result = [],
+        i, len, val;
+
+    // Always return an array.
+    if (!a) {
+        return result;
+    }
+
+    for (i = 0, len = a.length; i < len; ++i) {
+        val = a[i];
+
+        if (L.isArray(val)) {
+            // Recusively flattens any nested arrays.
+            result.push.apply(result, A.flatten(val));
+        } else {
+            result.push(val);
+        }
+    }
+
+    return result;
+};
+
+
+}, '@VERSION@', {"requires": ["yui-base"]});

package/build/array-invoke/array-invoke-debug.js

@@ -0,0 +1,40 @@
+YUI.add('array-invoke', function (Y, NAME) {
+
+/**
+@module collection
+@submodule array-invoke
+*/
+
+/**
+Executes a named method on each item in an array of objects. Items in the array
+that do not have a function by that name will be skipped.
+
+@example
+
+    Y.Array.invoke(arrayOfDrags, 'plug', Y.Plugin.DDProxy);
+
+@method invoke
+@param {Array} items Array of objects supporting the named method.
+@param {String} name the name of the method to execute on each item.
+@param {Any} [args*] Any number of additional args are passed as parameters to
+  the execution of the named method.
+@return {Array} All return values, indexed according to the item index.
+@static
+@for Array
+**/
+Y.Array.invoke = function(items, name) {
+    var args = Y.Array(arguments, 2, true),
+        isFunction = Y.Lang.isFunction,
+        ret = [];
+
+    Y.Array.each(Y.Array(items), function(item, i) {
+        if (item && isFunction(item[name])) {
+            ret[i] = item[name].apply(item, args);
+        }
+    });
+
+    return ret;
+};
+
+
+}, '@VERSION@', {"requires": ["yui-base"]});

package/build/array-invoke/array-invoke-min.js

@@ -0,0 +1 @@
+YUI.add("array-invoke",function(e,t){e.Array.invoke=function(t,n){var r=e.Array(arguments,2,!0),i=e.Lang.isFunction,s=[];return e.Array.each(e.Array(t),function(e,t){e&&i(e[n])&&(s[t]=e[n].apply(e,r))}),s}},"@VERSION@",{requires:["yui-base"]});

package/build/array-invoke/array-invoke.js

@@ -0,0 +1,40 @@
+YUI.add('array-invoke', function (Y, NAME) {
+
+/**
+@module collection
+@submodule array-invoke
+*/
+
+/**
+Executes a named method on each item in an array of objects. Items in the array
+that do not have a function by that name will be skipped.
+
+@example
+
+    Y.Array.invoke(arrayOfDrags, 'plug', Y.Plugin.DDProxy);
+
+@method invoke
+@param {Array} items Array of objects supporting the named method.
+@param {String} name the name of the method to execute on each item.
+@param {Any} [args*] Any number of additional args are passed as parameters to
+  the execution of the named method.
+@return {Array} All return values, indexed according to the item index.
+@static
+@for Array
+**/
+Y.Array.invoke = function(items, name) {
+    var args = Y.Array(arguments, 2, true),
+        isFunction = Y.Lang.isFunction,
+        ret = [];
+
+    Y.Array.each(Y.Array(items), function(item, i) {
+        if (item && isFunction(item[name])) {
+            ret[i] = item[name].apply(item, args);
+        }
+    });
+
+    return ret;
+};
+
+
+}, '@VERSION@', {"requires": ["yui-base"]});

package/build/arraylist/arraylist-debug.js

@@ -0,0 +1,214 @@
+YUI.add('arraylist', function (Y, NAME) {
+
+/**
+ * Collection utilities beyond what is provided in the YUI core
+ * @module collection
+ * @submodule arraylist
+ */
+
+var YArray      = Y.Array,
+    YArray_each = YArray.each,
+    ArrayListProto;
+
+/**
+ * Generic ArrayList class for managing lists of items and iterating operations
+ * over them.  The targeted use for this class is for augmentation onto a
+ * class that is responsible for managing multiple instances of another class
+ * (e.g. NodeList for Nodes).  The recommended use is to augment your class with
+ * ArrayList, then use ArrayList.addMethod to mirror the API of the constituent
+ * items on the list's API.
+ *
+ * The default implementation creates immutable lists, but mutability can be
+ * provided via the arraylist-add submodule or by implementing mutation methods
+ * directly on the augmented class's prototype.
+ *
+ * @class ArrayList
+ * @constructor
+ * @param items { Array } array of items this list will be responsible for
+ */
+function ArrayList( items ) {
+    if ( items !== undefined ) {
+        this._items = Y.Lang.isArray( items ) ? items : YArray( items );
+    } else {
+        // ||= to support lazy initialization from augment
+        this._items = this._items || [];
+    }
+}
+
+ArrayListProto = {
+    /**
+     * Get an item by index from the list.  Override this method if managing a
+     * list of objects that have a different public representation (e.g. Node
+     * instances vs DOM nodes).  The iteration methods that accept a user
+     * function will use this method for access list items for operation.
+     *
+     * @method item
+     * @param i { Integer } index to fetch
+     * @return { mixed } the item at the requested index
+     */
+    item: function ( i ) {
+        return this._items[i];
+    },
+
+    /**
+     * <p>Execute a function on each item of the list, optionally providing a
+     * custom execution context.  Default context is the item.</p>
+     *
+     * <p>The callback signature is <code>callback( item, index )</code>.</p>
+     *
+     * @method each
+     * @param fn { Function } the function to execute
+     * @param context { mixed } optional override 'this' in the function
+     * @return { ArrayList } this instance
+     * @chainable
+     */
+    each: function ( fn, context ) {
+        YArray_each( this._items, function ( item, i ) {
+            item = this.item( i );
+
+            fn.call( context || item, item, i, this );
+        }, this);
+
+        return this;
+    },
+
+    /**
+     * <p>Execute a function on each item of the list, optionally providing a
+     * custom execution context.  Default context is the item.</p>
+     *
+     * <p>The callback signature is <code>callback( item, index )</code>.</p>
+     *
+     * <p>Unlike <code>each</code>, if the callback returns true, the
+     * iteration will stop.</p>
+     *
+     * @method some
+     * @param fn { Function } the function to execute
+     * @param context { mixed } optional override 'this' in the function
+     * @return { Boolean } True if the function returned true on an item
+     */
+    some: function ( fn, context ) {
+        return YArray.some( this._items, function ( item, i ) {
+            item = this.item( i );
+
+            return fn.call( context || item, item, i, this );
+        }, this);
+    },
+
+    /**
+     * Finds the first index of the needle in the managed array of items.
+     *
+     * @method indexOf
+     * @param needle { mixed } The item to search for
+     * @return { Integer } Array index if found.  Otherwise -1
+     */
+    indexOf: function ( needle ) {
+        return YArray.indexOf( this._items, needle );
+    },
+
+    /**
+     * How many items are in this list?
+     *
+     * @method size
+     * @return { Integer } Number of items in the list
+     */
+    size: function () {
+        return this._items.length;
+    },
+
+    /**
+     * Is this instance managing any items?
+     *
+     * @method isEmpty
+     * @return { Boolean } true if 1 or more items are being managed
+     */
+    isEmpty: function () {
+        return !this.size();
+    },
+
+    /**
+     * Provides an array-like representation for JSON.stringify.
+     *
+     * @method toJSON
+     * @return { Array } an array representation of the ArrayList
+     */
+    toJSON: function () {
+        return this._items;
+    }
+};
+// Default implementation does not distinguish between public and private
+// item getter
+/**
+ * Protected method for optimizations that may be appropriate for API
+ * mirroring. Similar in functionality to <code>item</code>, but is used by
+ * methods added with <code>ArrayList.addMethod()</code>.
+ *
+ * @method _item
+ * @protected
+ * @param i { Integer } Index of item to fetch
+ * @return { mixed } The item appropriate for pass through API methods
+ */
+ArrayListProto._item = ArrayListProto.item;
+
+// Mixed onto existing proto to preserve constructor NOT being an own property.
+// This has bitten me when composing classes by enumerating, copying prototypes.
+Y.mix(ArrayList.prototype, ArrayListProto);
+
+Y.mix( ArrayList, {
+
+    /**
+     * <p>Adds a pass through method to dest (typically the prototype of a list
+     * class) that calls the named method on each item in the list with
+     * whatever parameters are passed in.  Allows for API indirection via list
+     * instances.</p>
+     *
+     * <p>Accepts a single string name or an array of string names.</p>
+     *
+     * <pre><code>list.each( function ( item ) {
+     *     item.methodName( 1, 2, 3 );
+     * } );
+     * // becomes
+     * list.methodName( 1, 2, 3 );</code></pre>
+     *
+     * <p>Additionally, the pass through methods use the item retrieved by the
+     * <code>_item</code> method in case there is any special behavior that is
+     * appropriate for API mirroring.</p>
+     *
+     * <p>If the iterated method returns a value, the return value from the
+     * added method will be an array of values with each value being at the
+     * corresponding index for that item.  If the iterated method does not
+     * return a value, the added method will be chainable.
+     *
+     * @method addMethod
+     * @static
+     * @param dest {Object} Object or prototype to receive the iterator method
+     * @param name {String|String[]} Name of method of methods to create
+     */
+    addMethod: function ( dest, names ) {
+
+        names = YArray( names );
+
+        YArray_each( names, function ( name ) {
+            dest[ name ] = function () {
+                var args = YArray( arguments, 0, true ),
+                    ret  = [];
+
+                YArray_each( this._items, function ( item, i ) {
+                    item = this._item( i );
+
+                    var result = item[ name ].apply( item, args );
+
+                    if ( result !== undefined && result !== item ) {
+                        ret[i] = result;
+                    }
+                }, this);
+
+                return ret.length ? ret : this;
+            };
+        } );
+    }
+} );
+
+Y.ArrayList = ArrayList;
+
+
+}, '@VERSION@', {"requires": ["yui-base"]});

package/build/arraylist/arraylist-min.js

@@ -0,0 +1 @@
+YUI.add("arraylist",function(e,t){function s(t){t!==undefined?this._items=e.Lang.isArray(t)?t:n(t):this._items=this._items||[]}var n=e.Array,r=n.each,i;i={item:function(e){return this._items[e]},each:function(e,t){return r(this._items,function(n,r){n=this.item(r),e.call(t||n,n,r,this)},this),this},some:function(e,t){return n.some(this._items,function(n,r){return n=this.item(r),e.call(t||n,n,r,this)},this)},indexOf:function(e){return n.indexOf(this._items,e)},size:function(){return this._items.length},isEmpty:function(){return!this.size()},toJSON:function(){return this._items}},i._item=i.item,e.mix(s.prototype,i),e.mix(s,{addMethod:function(e,t){t=n(t),r(t,function(t){e[t]=function(){var e=n(arguments,0,!0),i=[];return r(this._items,function(n,r){n=this._item(r);var s=n[t].apply(n,e);s!==undefined&&s!==n&&(i[r]=s)},this),i.length?i:this}})}}),e.ArrayList=s},"@VERSION@",{requires:["yui-base"]});