Function orderByFilter

OpenReservation/wwwroot/Scripts/angular.js:20904–21027

($parse)

    orderByFilter.$inject = ['$parse'];

    function orderByFilter($parse) {
        return function (array, sortPredicate, reverseOrder) {
            if (array == null) return array;
            if (!isArrayLike(array)) {
                throw minErr('orderBy')('notarray', 'Expected array but received: {0}', array);
            }

            if (!isArray(sortPredicate)) {
                sortPredicate = [sortPredicate];
            }
            if (sortPredicate.length === 0) {
                sortPredicate = ['+'];
            }

            var predicates = processPredicates(sortPredicate, reverseOrder);
            // Add a predicate at the end that evaluates to the element index. This makes the
            // sort stable as it works as a tie-breaker when all the input predicates cannot
            // distinguish between two elements.
            predicates.push({ get: function () { return {}; }, descending: reverseOrder ? -1 : 1 });

            // The next three lines are a version of a Swartzian Transform idiom from Perl
            // (sometimes called the Decorate-Sort-Undecorate idiom)
            // See https://en.wikipedia.org/wiki/Schwartzian_transform
            var compareValues = Array.prototype.map.call(array, getComparisonObject);
            compareValues.sort(doComparison);
            array = compareValues.map(function (item) { return item.value; });

            return array;

            function getComparisonObject(value, index) {
                return {
                    value: value,
                    predicateValues: predicates.map(function (predicate) {
                        return getPredicateValue(predicate.get(value), index);
                    })
                };
            }

            function doComparison(v1, v2) {
                var result = 0;
                for (var index = 0, length = predicates.length; index < length; ++index) {
                    result = compare(v1.predicateValues[index], v2.predicateValues[index]) *
                        predicates[index].descending;
                    if (result) break;
                }
                return result;
            }
        };

        function processPredicates(sortPredicate, reverseOrder) {
            reverseOrder = reverseOrder ? -1 : 1;
            return sortPredicate.map(function (predicate) {
                var descending = 1, get = identity;

                if (isFunction(predicate)) {
                    get = predicate;
                } else if (isString(predicate)) {
                    if ((predicate.charAt(0) == '+' || predicate.charAt(0) == '-')) {