Source: polyfill/Array.js

// Licensed Materials - Property of IBM
//
// IBM Watson Analytics
//
// (C) Copyright IBM Corp. 2015, 2018
//
// US Government Users Restricted Rights - Use, duplication or
// disclosure restricted by GSA ADP Schedule Contract with IBM Corp.
( function( Array, ObjectPolyfill, NMap, NSet )
{
"use strict";
// This module uses bitwise operators to enforce unsigned ints or perform other optimizations.
/*jshint bitwise:false*/
var toObject = ObjectPolyfill.toObject,
    isCallable = ObjectPolyfill.isCallable,
    ensureCallable = ObjectPolyfill.ensureCallable;
// Store reference to Object.prototype.toString for convenience and to (hopefully) grab the original before modification.
var toString = Object.prototype.toString;
/** @lends module:barejs/polyfill.Array */
var stat = {},
/** @lends module:barejs/polyfill.Array# */
    proto = {};
/**
 * Method that performs the actual iteration
 * @memberof module:barejs/polyfill.Array~
 * @private
 */
function iterate( _arrayLike, _callback, _thisArg, _logic )
{
    var asString = ( "charAt" in _arrayLike ) && ( "substr" in _arrayLike );
    for ( var i = 0, len = _arrayLike.length >>> 0, value, result; i < len; ++i )
    {
        if ( asString || ( i in _arrayLike ) )
        {
            result = _callback.call( _thisArg, value = asString ? _arrayLike.charAt( i ) : _arrayLike[i], i, _arrayLike );
            if ( _logic( value, i, result ) === true )
                break;
        }
    }
}
/**
 * Polyfills for {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array Array}.
 * @class module:barejs/polyfill.Array
 */
/*istanbul ignore else: We test with __ES__ set to 3*/
if ( __ES__ < 5 )
{
    /**
     * Enumerate all values in the array
     * @this {Array}
     * @param {function} _callback The callback to call for each value
     * @param {object} [_thisArg] Optional: the context in which the callback should be invoked
     */
    proto.forEach = function forEach( _callback/*, _thisArg (method has length 1)*/ )
    {
        iterate( toObject( this, forEach ), ensureCallable( _callback ), arguments[1], function() {/*no logic*/} );
    };
    /**
     * Check if callback returns true for every element
     * @this {Array}
     * @param {function} _callback The callback to test each value
     * @param {object} [_thisArg] Optional: the context in which the callback should be invoked
     * @returns {boolean} True if the callback returns true for each element, false otherwise.
     */
    proto.every = function every( _callback/*, _thisArg (method has length 1)*/ )
    {
        var result = true;
        iterate( toObject( this, every ), ensureCallable( _callback ), arguments[1], function( _v, _i, _r )
        {
            // If the callback returned a falsey value
            if ( !_r )
            {
                // The every statement doesn't hold true
                result = false;
                // Break execution
                return true;
            }
        } );
        return result;
    };
    /**
     * Check if callback returns true for any element
     * @this {Array}
     * @param {function} _callback The callback to test each value
     * @param {object} [_thisArg] Optional: the context in which the callback should be invoked
     * @returns {boolean} True if the callback returns true for at least one element, false otherwise.
     */
    proto.some = function some( _callback/*, _thisArg (method has length 1)*/ )
    {
        var result = false;
        iterate( toObject( this, some ), ensureCallable( _callback ), arguments[1], function( _v, _i, _r )
        {
            // If the callback returned a thruthy value, the some statement is true (shortcuted to return true for breaking)
            if ( _r )
                return ( result = true );
        } );
        return result;
    };
    /**
     * Creates a new array with only the elements matching the provided function.
     * @this {Array}
     * @param {function} _callback The callback to test each value.
     * @param {object} [_thisArg] Optional: the context in which the callback should be invoked
     * @returns {Array} A new array containing the result of callback per element.
     */
    proto.filter = function filter( _callback/*, _thisArg (method has length 1)*/ )
    {
        var result = [];
        iterate( toObject( this, filter ), ensureCallable( _callback ), arguments[1], function( _v, _i, _r )
        {
            // If the callback returned a thruthy value, add the value to the result
            if ( _r )
                result.push( _v );
        } );
        return result;
    };
    /**
     * Creates a new array with the results of calling a provided function on every element in this array.
     * @this {Array}
     * @param {function} _callback The callback to test each value
     * @param {object} [_thisArg] Optional: the context in which the callback should be invoked
     * @returns {Array} A new array containing the result of callback per element.
     */
    proto.map = function map( _callback/*, _thisArg (method has length 1)*/ )
    {
        var o = toObject( this, map ), result = new Array( o.length >>> 0 );
        iterate( o, ensureCallable( _callback ), arguments[1], function( _v, _i, _r )
        {
            result[_i] = _r;
        } );
        return result;
    };
    /**
     * Returns the first index at which a given element can be found in the array, or -1 if it is not present.
     * @this {Array}
     * @param {object} _searchElement Element to locate in the array.
     * @param {number} [_fromIndex=0] Optional: The index to start the search at. Default: 0
     *      If the index is greater than or equal to the array's length, -1 is returned, which means
     *      the array will not be searched. If the provided index value is a negative number, it is
     *      taken as the offset from the end of the array. Note: if the provided index is negative,
     *      the array is still searched from front to back. If the calculated index is less than 0,
     *      then the whole array will be searched.
     * @returns {number} The first index at which a given element can be found in the array, or -1 if it is not present.
     */
    proto.indexOf = function indexOf( _searchElement/*, _fromIndex*/ )
    {
        var t = toObject( this, indexOf ), len = t.length >>> 0, i = 0;
        if ( len < 1 )
            return -1;
        if ( arguments.length >= 2 )
        {
            if ( ( i = arguments[1] >> 0 ) < 0 )
                i = Math.max( 0, len + i );
        }
        for ( ; i < len; ++i )
            if ( ( i in t ) && ( t[i] === _searchElement ) )
                return i;
        return -1;
    };
    /**
     * Returns the last index at which a given element can be found in the array, or -1 if it is not present.
     * The array is searched backwards, starting at fromIndex.
     * @this {Array}
     * @param {object} _searchElement Element to locate in the array.
     * @param {number} [_fromIndex=-1] Optional: The index at which to start searching backwards.
     *      Defaults to the array's length - 1, i.e. the whole array will be searched. If the index is
     *      greater than or equal to the length of the array, the whole array will be searched.
     *      If negative, it is taken as the offset from the end of the array. Note that even when
     *      the index is negative, the array is still searched from back to front. If the calculated
     *      index is less than 0, -1 is returned, i.e. the array will not be searched.
     * @returns {number} The last index at which a given element can be found in the array, or -1 if it is not present.
     */
    proto.lastIndexOf = function lastIndexOf( _searchElement/*, _fromIndex*/ )
    {
        var t = toObject( this, lastIndexOf ), len = t.length >>> 0, i = len - 1;
        if ( len < 1 )
            return -1;
        if ( arguments.length >= 2 )
        {
            if ( ( i = Math.min( i, arguments[1] >> 0 ) ) < 0 )
                i += len;
        }
        for ( ; i >= 0; --i )
            if ( ( i in this ) && ( this[i] === _searchElement ) )
                return i;
        return -1;
    };
    /**
     * The reduce() method applies a function against an accumulator and each value of the
     * array (from left-to-right) has to reduce it to a single value.
     * @this {Array}
     * @param {function} _callback The callback to call for each value, taking 4 arguments:
     *              previousValue
     *                  The value previously returned in the last invocation of the callback, or initialValue, if supplied. (See below.)
     *              currentValue
     *                  The current element being processed in the array.
     *              index
     *                  The index of the current element being processed in the array.
     *              array
     *                  The array reduce was called upon.
     * @param {object} [_initialValue] Optional: a value to pass to the first callback.
     */
    proto.reduce = function reduce( _callback/*, _initialValue*/ )
    {
        var t = toObject( this, reduce ), len = t.length >>> 0, i = ensureCallable( _callback, 0 ), value;
        if ( arguments.length >= 2 )
        {
            value = arguments[1];
        }
        else
        {
            while ( ( i < len ) && !( i in t ) )
                ++i;
            if ( i >= len )
                throw new TypeError( "Reduce of empty array with no initial value" );
            value = t[i++];
        }
        for (; i < len; ++i)
        {
            if ( i in t )
                value = _callback( value, t[i], i, t );
        }
        return value;
    };
    /**
     * The reduceRight() method applies a function against an accumulator and each value of the
     * array (from right-to-left) has to reduce it to a single value.
     * @this {Array}
     * @param {function} _callback The callback to call for each value, taking 4 arguments:
     *              previousValue
     *                  The value previously returned in the last invocation of the callback, or initialValue, if supplied. (See below.)
     *              currentValue
     *                  The current element being processed in the array.
     *              index
     *                  The index of the current element being processed in the array.
     *              array
     *                  The array reduce was called upon.
     * @param {object} [_initialValue] Optional: a value to pass to the first callback.
     */
    proto.reduceRight = function reduceRight( _callback/*, _initialValue*/ )
    {
        var t = toObject( this, reduceRight ), len = t.length >>> 0, i = ensureCallable( _callback, len - 1 ), value;
        if ( arguments.length >= 2 )
        {
            value = arguments[1];
        }
        else
        {
            while ( ( i >= 0 ) && !( i in t ) )
                --i;
            if ( i < 0 )
                throw new TypeError( "Reduce of empty array with no initial value" );
            value = t[i--];
        }
        for (; i >= 0; --i)
        {
            if ( i in t )
                value = _callback( value, t[i], i, t );
        }
        return value;
    };
    /**
     * Check if an object is an array.
     * @param _arg The object to check.
     * @returns {boolean} true if an object is an array, false if it is not.
     */
    stat.isArray = function isArray( _arg )
    {
        return toString.call( _arg ) === "[object Array]";
    };
// End of ES5 polyfill scope
}
/*istanbul ignore else: We test with __ES__ set to 3 */
if ( __ES__ < 6 )
{
    /**
     * Find a value in the array
     * @param {function} _callback The callback to test each value in the array. If the value matches, it should return true.
     * @param {object} [_thisArg] Optional: the context in which the callback should be invoked
     * @returns the found value or undefined if not found.
     */
    proto.find = function find( _callback/*, _thisArg (method has length 1)*/ )
    {
        var result = void undefined;
        iterate( toObject( this, find ), ensureCallable( _callback ), arguments[1], function( _v, _i, _r )
        {
            // If the callback returned a thruthy value, the result is found
            if ( _r )
            {
                result = _v;
                // Break the loop
                return true;
            }
        } );
        return result;
    };
    /**
     * Find a value in the array
     * @param {function} _callback The callback to test each value in the array. If the value matches, it should return true.
     * @param {object} [_thisArg] Optional: the context in which the callback should be invoked
     * @returns {number} the found index or -1 if not found.
     */
    proto.findIndex = function findIndex( _callback/*, _thisArg (method has length 1)*/ )
    {
        var result = -1;
        iterate( toObject( this, findIndex ), ensureCallable( _callback ), arguments[1], function( _v, _i, _r )
        {
            // If the callback returned a thruthy value, the result is found
            if ( _r )
            {
                result = _i;
                // Break the loop
                return true;
            }
        } );
        return result;
    };
    /**
     * The fill() method fills all the elements of an array from a start index to an end index with a static value.
     * @param _value The value to set to each index
     * @param {number} [_start=0] Optional: the index to start filling (inclusive)
     * If _start is negative, it is treated as length + _start.
     * @param {number} [_end] Optional: the index at which to stop filling (exclusive)
     * If _end is negative, it is treated as length + _end.
     */
    proto.fill = function fill( _value/*, _start, _end*/ )
    {
        var t = toObject( this, fill ), len = t.length >>> 0, i = arguments[1] >> 0, end = arguments[2];
        if ( i < 0 )
            i = Math.max( 0, i + len );
        if ( end === undefined )
            end = len;
        else if ( end < 0 )
            end = Math.max( 0, end + len );
        for ( ; i < end; ++i )
            t[i] = _value;
        return t;
    };
    /**
     * The Array.of() method creates a new Array instance with a variable number of arguments,
     * regardless of number or type of the arguments.
     * @param {...any} _value Any number of values that will be the content of the array.
     * @returns {Array} The created Array.
     */
    stat.of = function of()
    {
        var C = this;
        var args = arguments;
        var len = args.length;
        var result = isCallable( C ) ? Object( new C( len ) ) : new Array( len );
        for ( var  i = 0; i < len; ++i )
            result[i] = args[i];
        return result;
    };
    /**
     * The Array.from() method creates a new Array instance from an array-like or iterable object.
     * @param {object} _arrayLike An array-like or iterable object to convert to an array.
     * @param {function} [_mapFn] Optional. Map function to call on every element of the array.
     * @param {object} [_thisArg] Optional. Value to use as this when executing mapFn.
     * @returns {Array} The created Array.
     */
    stat.from = function from( _arrayLike/*, _mapFn, _thisArg*/ )
    {
        var C = this;
        var items = toObject( _arrayLike );
        var mapFn = typeof arguments[1] !== "undefined" ? ensureCallable( arguments[1] ) : null;
        var thisArg = arguments[2];
        // Iterators can't be emulated, but add specific logic for Map and Set so those are supported
        // Note: check both for a potential global and the polyfill separately:
        // NMap and Map MAY point to the same function, but don't have to in every environment (!).
        var isMap = items instanceof NMap;
        // Normalize to an Array, source. Chances are high we can just return this Array, or map it in place.
        var source;
        var i, len;
        if ( mapFn )
        {
            if ( thisArg === undefined )
                thisArg = null;
            else if ( thisArg !== null )
                thisArg = Object( thisArg );
        }
        var it = isCallable( items.next ) ? items : ObjectPolyfill.getIterator( items );
        if ( it )
        {
            source = [];
            for ( var cur = it.next(); !cur.done; cur = it.next() )
                source.push( cur.value );
            len = source.length;
        }
        // IE11's native map and set support forEach, but not iterators. Emulate using forEach.
        else if ( ( isMap || ( items instanceof NSet ) ) && isCallable( items.forEach ) )
        {
            i = 0;
            len = Math.floor( items.size ) || 0;
            source = new Array( len );
            items.forEach( function( _value, _key )
            {
                var entry;
                if ( isMap )
                {
                    entry = new Array( 2 );
                    entry[0] = _key;
                    entry[1] = _value;
                }
                else
                {
                    entry = _value;
                }
                source[ i++ ] = entry;
            } );
        }
        if ( !source )
        {
            var asString = ( "charAt" in items ) && ( "substr" in items );
            len = Math.floor( items.length ) || 0;
            source = new Array( len );
            for ( i = 0; i < len; ++i )
                source[i] = asString ? items.charAt( i ) : items[i];
        }
        // We already have an Array (source), only create a new Object if we have a Constructor as context
        var result = isCallable( C ) && C !== Array ? Object( new C( len ) ) : source;
        if ( mapFn || result !== source )
        {
            for ( i = 0; i < len; ++i )
                result[i] = mapFn ? mapFn.call( thisArg, source[i], i ) : source[i];
        }
        return result;
    };
// End of ES6 polyfill scope
}
/*istanbul ignore else: We test with __ES__ set to 3*/
if ( __ES__ < 7 )
{
    /**
     * The includes() method determines whether an array includes a certain element, returning true or false as appropriate.
     * The array is searched forwards, starting at fromIndex (defaults to 0).
     * @param {object} _searchElement Element to locate in the array.
     * @param {object} [_fromIndex=0] Optional: The index to start the search at. Default: 0
     *      If the index is greater than or equal to the array's length, -1 is returned, which means
     *      the array will not be searched. If the provided index value is a negative number, it is
     *      taken as the offset from the end of the array. Note: if the provided index is negative,
     *      the array is still searched from front to back. If the calculated index is less than 0,
     *      then the whole array will be searched.
     * @returns {boolean} True if the element was found, false otherwise.
     */
    proto.includes = function includes( _searchElement/*, _fromIndex*/ )
    {
        var t = toObject( this, includes ), len = t.length >>> 0, i = 0;
        if ( len < 1 )
            return false;
        if ( arguments.length > 1 )
        {
            if ( ( i = arguments[1] >> 0 ) < 0 )
                i = Math.max( 0, len + i );
        }
        for ( ; i < len; ++i )
            if ( ( t[i] === _searchElement ) || ( _searchElement !== _searchElement && t[i] !== t[i] ) )
                return true;
        return false;
    };
// End of ES7 polyfill scope
}
ObjectPolyfill.polyfill( Array, stat, proto, exports, "Array" );
// End of module
}( Array, require( "./Object" ), require( "../NMap" ), require( "../NSet" ) ) );