angular-pipes
Version:
Angular pipes library
1,500 lines (1,455 loc) • 127 kB
JavaScript
(function (global, factory) {
typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@angular/core')) :
typeof define === 'function' && define.amd ? define('angular-pipes', ['exports', '@angular/core'], factory) :
(global = global || self, factory(global['angular-pipes'] = {}, global.ng.core));
}(this, function (exports, core) { 'use strict';
/*! *****************************************************************************
Copyright (c) Microsoft Corporation. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use
this file except in compliance with the License. You may obtain a copy of the
License at http://www.apache.org/licenses/LICENSE-2.0
THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
MERCHANTABLITY OR NON-INFRINGEMENT.
See the Apache Version 2.0 License for specific language governing permissions
and limitations under the License.
***************************************************************************** */
function __decorate(decorators, target, key, desc) {
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
return c > 3 && r && Object.defineProperty(target, key, r), r;
}
function __values(o) {
var m = typeof Symbol === "function" && o[Symbol.iterator], i = 0;
if (m) return m.call(o);
return {
next: function () {
if (o && i >= o.length) o = void 0;
return { value: o && o[i++], done: !o };
}
};
}
function __read(o, n) {
var m = typeof Symbol === "function" && o[Symbol.iterator];
if (!m) return o;
var i = m.call(o), r, ar = [], e;
try {
while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
}
catch (error) { e = { error: error }; }
finally {
try {
if (r && !r.done && (m = i["return"])) m.call(i);
}
finally { if (e) throw e.error; }
}
return ar;
}
function __spread() {
for (var ar = [], i = 0; i < arguments.length; i++)
ar = ar.concat(__read(arguments[i]));
return ar;
}
function isUndefined(value) {
return typeof value === 'undefined';
}
function isNull(value) {
return value === null;
}
function isNumber(value) {
return typeof value === 'number';
}
function isNumberFinite(value) {
return isNumber(value) && isFinite(value);
}
// Not strict positive
function isPositive(value) {
return value >= 0;
}
function isInteger(value) {
// No rest, is an integer
return value % 1 === 0;
}
function isNil(value) {
return value === null || typeof value === 'undefined';
}
function isString(value) {
return typeof value === 'string';
}
function isObject(value) {
return value !== null && typeof value === 'object';
}
function isArray(value) {
return Array.isArray(value);
}
function isFunction(value) {
return typeof value === 'function';
}
function toDecimal(value, decimal) {
return Math.round(value * Math.pow(10, decimal)) / Math.pow(10, decimal);
}
function upperFirst(value) {
return value.slice(0, 1).toUpperCase() + value.slice(1);
}
function createRound(method) {
// <any>Math to suppress error
var func = Math[method];
return function (value, precision) {
if (precision === void 0) { precision = 0; }
if (typeof value === 'string') {
throw new TypeError('Rounding method needs a number');
}
if (typeof precision !== 'number' || isNaN(precision)) {
precision = 0;
}
if (precision) {
var pair = (value + "e").split('e');
var val = func(pair[0] + "e" + (+pair[1] + precision));
pair = (val + "e").split('e');
return +(pair[0] + 'e' + (+pair[1] - precision));
}
return func(value);
};
}
function leftPad(str, len, ch) {
if (len === void 0) { len = 0; }
if (ch === void 0) { ch = ' '; }
str = String(str);
ch = toString(ch);
var i = -1;
var length = len - str.length;
while (++i < length && str.length + ch.length <= len) {
str = ch + str;
}
return str;
}
function rightPad(str, len, ch) {
if (len === void 0) { len = 0; }
if (ch === void 0) { ch = ' '; }
str = String(str);
ch = toString(ch);
var i = -1;
var length = len - str.length;
while (++i < length && str.length + ch.length <= len) {
str += ch;
}
return str;
}
function toString(value) {
return "" + value;
}
function pad(str, len, ch) {
if (len === void 0) { len = 0; }
if (ch === void 0) { ch = ' '; }
str = String(str);
ch = toString(ch);
var i = -1;
var length = len - str.length;
var left = true;
while (++i < length) {
var l = str.length + ch.length <= len ? str.length + ch.length : str.length + 1;
if (left) {
str = leftPad(str, l, ch);
}
else {
str = rightPad(str, l, ch);
}
left = !left;
}
return str;
}
function flatten(input, index) {
if (index === void 0) { index = 0; }
if (index >= input.length) {
return input;
}
if (isArray(input[index])) {
return flatten(input.slice(0, index).concat(input[index], input.slice(index + 1)), index);
}
return flatten(input, index + 1);
}
function getProperty(value, key) {
var e_1, _a;
if (isNil(value) || !isObject(value)) {
return undefined;
}
var keys = key.split('.');
var result = value[keys.shift()];
try {
for (var keys_1 = __values(keys), keys_1_1 = keys_1.next(); !keys_1_1.done; keys_1_1 = keys_1.next()) {
var key_1 = keys_1_1.value;
if (isNil(result) || !isObject(result)) {
return undefined;
}
result = result[key_1];
}
}
catch (e_1_1) { e_1 = { error: e_1_1 }; }
finally {
try {
if (keys_1_1 && !keys_1_1.done && (_a = keys_1.return)) _a.call(keys_1);
}
finally { if (e_1) throw e_1.error; }
}
return result;
}
function sum(input, initial) {
if (initial === void 0) { initial = 0; }
return input.reduce(function (previous, current) { return previous + current; }, initial);
}
// http://stackoverflow.com/questions/6274339/how-can-i-shuffle-an-array-in-javascript
function shuffle(input) {
if (!isArray(input)) {
return input;
}
var copy = __spread(input);
for (var i = copy.length; i; --i) {
var j = Math.floor(Math.random() * i);
var x = copy[i - 1];
copy[i - 1] = copy[j];
copy[j] = x;
}
return copy;
}
function deepIndexOf(collection, value) {
var index = -1;
var length = collection.length;
while (++index < length) {
if (deepEqual(value, collection[index])) {
return index;
}
}
return -1;
}
function deepEqual(a, b) {
if (a === b) {
return true;
}
if (!(typeof a === 'object' && typeof b === 'object')) {
return a === b;
}
var keysA = Object.keys(a);
var keysB = Object.keys(b);
if (keysA.length !== keysB.length) {
return false;
}
// Test for A's keys different from B.
var hasOwn = Object.prototype.hasOwnProperty;
for (var i = 0; i < keysA.length; i++) {
var key = keysA[i];
if (!hasOwn.call(b, keysA[i]) || !deepEqual(a[key], b[key])) {
return false;
}
}
return true;
}
function isDeepObject(object) {
return object.__isDeepObject__;
}
function wrapDeep(object) {
return new DeepWrapper(object);
}
function unwrapDeep(object) {
if (isDeepObject(object)) {
return object.data;
}
return object;
}
var DeepWrapper = /** @class */ (function () {
function DeepWrapper(data) {
this.data = data;
this.__isDeepObject__ = true;
}
return DeepWrapper;
}());
function count(input) {
if (!isArray(input) && !isObject(input) && !isString(input)) {
return input;
}
if (isObject(input)) {
return Object.keys(input).map(function (value) { return input[value]; }).length;
}
return input.length;
}
function empty(input) {
if (!isArray(input)) {
return input;
}
return input.length === 0;
}
function every(input, predicate) {
if (!isArray(input) || !predicate) {
return input;
}
var result = true;
var i = -1;
while (++i < input.length && result) {
result = predicate(input[i], i, input);
}
return result;
}
function takeUntil(input, predicate) {
var i = -1;
var result = [];
while (++i < input.length && !predicate(input[i], i, input)) {
result[i] = input[i];
}
return result;
}
function takeWhile(input, predicate) {
return takeUntil(input, function (item, index, collection) { return !predicate(item, index, collection); });
}
var GroupByPipe = /** @class */ (function () {
function GroupByPipe() {
}
GroupByPipe.prototype.transform = function (input, prop) {
var e_1, _a;
if (!isArray(input)) {
return input;
}
var arr = {};
try {
for (var input_1 = __values(input), input_1_1 = input_1.next(); !input_1_1.done; input_1_1 = input_1.next()) {
var value = input_1_1.value;
var field = getProperty(value, prop);
if (isUndefined(arr[field])) {
arr[field] = [];
}
arr[field].push(value);
}
}
catch (e_1_1) { e_1 = { error: e_1_1 }; }
finally {
try {
if (input_1_1 && !input_1_1.done && (_a = input_1.return)) _a.call(input_1);
}
finally { if (e_1) throw e_1.error; }
}
return Object.keys(arr).map(function (key) { return ({ key: key, value: arr[key] }); });
};
GroupByPipe = __decorate([
core.Pipe({
name: 'groupBy',
})
], GroupByPipe);
return GroupByPipe;
}());
var NgGroupByPipeModule = /** @class */ (function () {
function NgGroupByPipeModule() {
}
NgGroupByPipeModule = __decorate([
core.NgModule({
declarations: [GroupByPipe],
exports: [GroupByPipe],
})
], NgGroupByPipeModule);
return NgGroupByPipeModule;
}());
var MaxPipe = /** @class */ (function () {
function MaxPipe() {
}
MaxPipe.prototype.transform = function (input) {
if (!isArray(input)) {
return input;
}
if (input.length === 0) {
return undefined;
}
var max = input[0];
input.forEach(function (value) {
if (max < value) {
max = value;
}
});
return max;
};
MaxPipe = __decorate([
core.Pipe({
name: 'max',
})
], MaxPipe);
return MaxPipe;
}());
var NgMaxPipeModule = /** @class */ (function () {
function NgMaxPipeModule() {
}
NgMaxPipeModule = __decorate([
core.NgModule({
declarations: [MaxPipe],
exports: [MaxPipe],
})
], NgMaxPipeModule);
return NgMaxPipeModule;
}());
var MeanPipe = /** @class */ (function () {
function MeanPipe() {
}
MeanPipe.prototype.transform = function (input) {
if (!isArray(input)) {
return input;
}
var count = input.length;
if (count === 0) {
return undefined;
}
return sum(input) / count;
};
MeanPipe = __decorate([
core.Pipe({
name: 'mean',
})
], MeanPipe);
return MeanPipe;
}());
var NgMeanPipeModule = /** @class */ (function () {
function NgMeanPipeModule() {
}
NgMeanPipeModule = __decorate([
core.NgModule({
declarations: [MeanPipe],
exports: [MeanPipe],
})
], NgMeanPipeModule);
return NgMeanPipeModule;
}());
var MinPipe = /** @class */ (function () {
function MinPipe() {
}
MinPipe.prototype.transform = function (input) {
if (!isArray(input)) {
return input;
}
if (input.length === 0) {
return undefined;
}
var min = input[0];
input.forEach(function (value) {
if (min > value) {
min = value;
}
});
return min;
};
MinPipe = __decorate([
core.Pipe({
name: 'min',
})
], MinPipe);
return MinPipe;
}());
var NgMinPipeModule = /** @class */ (function () {
function NgMinPipeModule() {
}
NgMinPipeModule = __decorate([
core.NgModule({
declarations: [MinPipe],
exports: [MinPipe],
})
], NgMinPipeModule);
return NgMinPipeModule;
}());
var SumPipe = /** @class */ (function () {
function SumPipe() {
}
SumPipe.prototype.transform = function (input) {
return !isArray(input) ? input : sum(input);
};
SumPipe = __decorate([
core.Pipe({ name: 'sum' })
], SumPipe);
return SumPipe;
}());
var NgSumPipeModule = /** @class */ (function () {
function NgSumPipeModule() {
}
NgSumPipeModule = __decorate([
core.NgModule({
declarations: [SumPipe],
exports: [SumPipe],
})
], NgSumPipeModule);
return NgSumPipeModule;
}());
var NgAggregatePipesModule = /** @class */ (function () {
function NgAggregatePipesModule() {
}
NgAggregatePipesModule = __decorate([
core.NgModule({
imports: [NgGroupByPipeModule, NgMaxPipeModule, NgMeanPipeModule, NgMinPipeModule, NgSumPipeModule],
})
], NgAggregatePipesModule);
return NgAggregatePipesModule;
}());
var EmptyPipe = /** @class */ (function () {
function EmptyPipe() {
}
EmptyPipe.prototype.transform = function (input) {
return empty(input);
};
EmptyPipe = __decorate([
core.Pipe({
name: 'empty',
})
], EmptyPipe);
return EmptyPipe;
}());
var NgEmptyPipeModule = /** @class */ (function () {
function NgEmptyPipeModule() {
}
NgEmptyPipeModule = __decorate([
core.NgModule({
declarations: [EmptyPipe],
exports: [EmptyPipe],
})
], NgEmptyPipeModule);
return NgEmptyPipeModule;
}());
var HeadPipe = /** @class */ (function () {
function HeadPipe() {
}
HeadPipe.prototype.transform = function (input) {
if (!isArray(input)) {
return input;
}
// Will return undefined if length is 0
return input[0];
};
HeadPipe = __decorate([
core.Pipe({
name: 'head',
})
], HeadPipe);
return HeadPipe;
}());
var NgHeadPipeModule = /** @class */ (function () {
function NgHeadPipeModule() {
}
NgHeadPipeModule = __decorate([
core.NgModule({
declarations: [HeadPipe],
exports: [HeadPipe],
})
], NgHeadPipeModule);
return NgHeadPipeModule;
}());
var InitialPipe = /** @class */ (function () {
function InitialPipe() {
}
InitialPipe.prototype.transform = function (input) {
if (!isArray(input)) {
return input;
}
return input.slice(0, input.length - 1);
};
InitialPipe = __decorate([
core.Pipe({
name: 'initial',
})
], InitialPipe);
return InitialPipe;
}());
var NgInitialPipeModule = /** @class */ (function () {
function NgInitialPipeModule() {
}
NgInitialPipeModule = __decorate([
core.NgModule({
declarations: [InitialPipe],
exports: [InitialPipe],
})
], NgInitialPipeModule);
return NgInitialPipeModule;
}());
var LastPipe = /** @class */ (function () {
function LastPipe() {
}
LastPipe.prototype.transform = function (input) {
if (!isArray(input)) {
return input;
}
// Returns undefined if empty
return input[input.length - 1];
};
LastPipe = __decorate([
core.Pipe({
name: 'last',
})
], LastPipe);
return LastPipe;
}());
var NgLastPipeModule = /** @class */ (function () {
function NgLastPipeModule() {
}
NgLastPipeModule = __decorate([
core.NgModule({
declarations: [LastPipe],
exports: [LastPipe],
})
], NgLastPipeModule);
return NgLastPipeModule;
}());
var JoinPipe = /** @class */ (function () {
function JoinPipe() {
}
JoinPipe.prototype.transform = function (input, character) {
if (character === void 0) { character = ''; }
if (!isArray(input)) {
return input;
}
return input.join(character);
};
JoinPipe = __decorate([
core.Pipe({
name: 'join',
})
], JoinPipe);
return JoinPipe;
}());
var NgJoinPipeModule = /** @class */ (function () {
function NgJoinPipeModule() {
}
NgJoinPipeModule = __decorate([
core.NgModule({
declarations: [JoinPipe],
exports: [JoinPipe],
})
], NgJoinPipeModule);
return NgJoinPipeModule;
}());
var TailPipe = /** @class */ (function () {
function TailPipe() {
}
TailPipe.prototype.transform = function (input) {
if (!isArray(input)) {
return input;
}
return input.slice(1, input.length);
};
TailPipe = __decorate([
core.Pipe({
name: 'tail',
})
], TailPipe);
return TailPipe;
}());
var NgTailPipeModule = /** @class */ (function () {
function NgTailPipeModule() {
}
NgTailPipeModule = __decorate([
core.NgModule({
declarations: [TailPipe],
exports: [TailPipe],
})
], NgTailPipeModule);
return NgTailPipeModule;
}());
var UniqPipe = /** @class */ (function () {
function UniqPipe() {
}
UniqPipe.prototype.transform = function (input) {
if (!isArray(input) && !isDeepObject(input)) {
return input;
}
if (isDeepObject(input)) {
var unwrappedInput_1 = unwrapDeep(input);
if (!isArray(unwrappedInput_1)) {
return unwrappedInput_1;
}
return unwrappedInput_1.filter(function (value, index) { return deepIndexOf(unwrappedInput_1, value) === index; });
}
return input.filter(function (value, index) { return input.indexOf(value) === index; });
};
UniqPipe = __decorate([
core.Pipe({
name: 'uniq',
})
], UniqPipe);
return UniqPipe;
}());
var NgUniqPipeModule = /** @class */ (function () {
function NgUniqPipeModule() {
}
NgUniqPipeModule = __decorate([
core.NgModule({
declarations: [UniqPipe],
exports: [UniqPipe],
})
], NgUniqPipeModule);
return NgUniqPipeModule;
}());
var WithoutPipe = /** @class */ (function () {
function WithoutPipe() {
}
WithoutPipe.prototype.transform = function (input) {
var args = [];
for (var _i = 1; _i < arguments.length; _i++) {
args[_i - 1] = arguments[_i];
}
if (!isArray(input) && !isDeepObject(input)) {
return input;
}
if (isDeepObject(input)) {
var unwrappedInput = unwrapDeep(input);
if (!isArray(unwrappedInput)) {
return unwrappedInput;
}
return unwrappedInput.filter(function (value) { return deepIndexOf(args, value) === -1; });
}
return input.filter(function (value) { return args.indexOf(value) === -1; });
};
WithoutPipe = __decorate([
core.Pipe({
name: 'without',
})
], WithoutPipe);
return WithoutPipe;
}());
var NgWithoutPipeModule = /** @class */ (function () {
function NgWithoutPipeModule() {
}
NgWithoutPipeModule = __decorate([
core.NgModule({
declarations: [WithoutPipe],
exports: [WithoutPipe],
})
], NgWithoutPipeModule);
return NgWithoutPipeModule;
}());
var MapPipe = /** @class */ (function () {
function MapPipe() {
}
MapPipe.prototype.transform = function (input, fn) {
if (!isArray(input) || !fn) {
return input;
}
return input.map(fn);
};
MapPipe = __decorate([
core.Pipe({
name: 'map',
})
], MapPipe);
return MapPipe;
}());
var NgMapPipeModule = /** @class */ (function () {
function NgMapPipeModule() {
}
NgMapPipeModule = __decorate([
core.NgModule({
declarations: [MapPipe],
exports: [MapPipe],
})
], NgMapPipeModule);
return NgMapPipeModule;
}());
var WherePipe = /** @class */ (function () {
function WherePipe() {
}
/**
* Support a function or a value or the shorthand ['key', value] like the lodash shorthand.
*/
WherePipe.prototype.transform = function (input, fn) {
if (!isArray(input)) {
return input;
}
if (isFunction(fn)) {
return input.filter(fn);
}
else if (isArray(fn)) {
var _a = __read(fn, 2), key_1 = _a[0], value_1 = _a[1];
return input.filter(function (item) { return getProperty(item, key_1) === value_1; });
}
else if (fn) {
return input.filter(function (item) { return item === fn; });
}
else {
return input;
}
};
WherePipe = __decorate([
core.Pipe({
name: 'where',
})
], WherePipe);
return WherePipe;
}());
var NgWherePipeModule = /** @class */ (function () {
function NgWherePipeModule() {
}
NgWherePipeModule = __decorate([
core.NgModule({
declarations: [WherePipe],
exports: [WherePipe],
})
], NgWherePipeModule);
return NgWherePipeModule;
}());
var FirstOrDefaultPipe = /** @class */ (function () {
function FirstOrDefaultPipe() {
}
FirstOrDefaultPipe_1 = FirstOrDefaultPipe;
FirstOrDefaultPipe.find = function (input, predicate, defaultValue) {
var found = false;
var result;
var i = -1;
while (!found && ++i < input.length) {
found = predicate(input[i], i, input);
}
if (found) {
result = input[i];
}
if (typeof result === 'undefined' && typeof defaultValue !== 'undefined') {
result = defaultValue;
}
return result;
};
FirstOrDefaultPipe.prototype.transform = function (input, predicate, defaultValue) {
if (!isArray(input)) {
return input;
}
if (isFunction(predicate)) {
return FirstOrDefaultPipe_1.find(input, predicate, defaultValue);
}
else if (isArray(predicate)) {
var _a = __read(predicate, 2), key_1 = _a[0], value_1 = _a[1];
return FirstOrDefaultPipe_1.find(input, function (item) { return getProperty(item, key_1) === value_1; }, defaultValue);
}
else if (predicate) {
return FirstOrDefaultPipe_1.find(input, function (item) { return item === predicate; }, defaultValue);
}
else {
return input;
}
};
var FirstOrDefaultPipe_1;
FirstOrDefaultPipe = FirstOrDefaultPipe_1 = __decorate([
core.Pipe({
name: 'firstOrDefault',
})
], FirstOrDefaultPipe);
return FirstOrDefaultPipe;
}());
var NgFirstOrDefaultPipeModule = /** @class */ (function () {
function NgFirstOrDefaultPipeModule() {
}
NgFirstOrDefaultPipeModule = __decorate([
core.NgModule({
declarations: [FirstOrDefaultPipe],
exports: [FirstOrDefaultPipe],
})
], NgFirstOrDefaultPipeModule);
return NgFirstOrDefaultPipeModule;
}());
var RangePipe = /** @class */ (function () {
function RangePipe() {
}
RangePipe.prototype.transform = function (_input, size, start, step) {
if (size === void 0) { size = 0; }
if (start === void 0) { start = 1; }
if (step === void 0) { step = 1; }
var range = [];
for (var length_1 = 0; length_1 < size; ++length_1) {
range.push(start);
start += step;
}
return range;
};
RangePipe = __decorate([
core.Pipe({
name: 'range',
})
], RangePipe);
return RangePipe;
}());
var NgRangePipeModule = /** @class */ (function () {
function NgRangePipeModule() {
}
NgRangePipeModule = __decorate([
core.NgModule({
declarations: [RangePipe],
exports: [RangePipe],
})
], NgRangePipeModule);
return NgRangePipeModule;
}());
var PluckPipe = /** @class */ (function () {
function PluckPipe() {
}
PluckPipe.prototype.transform = function (input, key) {
if (!isArray(input) || !key) {
return input;
}
return input.map(function (value) {
return getProperty(value, key);
});
};
PluckPipe = __decorate([
core.Pipe({
name: 'pluck',
})
], PluckPipe);
return PluckPipe;
}());
var NgPluckPipeModule = /** @class */ (function () {
function NgPluckPipeModule() {
}
NgPluckPipeModule = __decorate([
core.NgModule({
declarations: [PluckPipe],
exports: [PluckPipe],
})
], NgPluckPipeModule);
return NgPluckPipeModule;
}());
var ReversePipe = /** @class */ (function () {
function ReversePipe() {
}
ReversePipe.prototype.transform = function (input) {
if (!isArray(input)) {
return input;
}
return __spread(input).reverse();
};
ReversePipe = __decorate([
core.Pipe({
name: 'reverse',
})
], ReversePipe);
return ReversePipe;
}());
var NgReversePipeModule = /** @class */ (function () {
function NgReversePipeModule() {
}
NgReversePipeModule = __decorate([
core.NgModule({
declarations: [ReversePipe],
exports: [ReversePipe],
})
], NgReversePipeModule);
return NgReversePipeModule;
}());
var OrderByPipe = /** @class */ (function () {
function OrderByPipe() {
}
OrderByPipe_1 = OrderByPipe;
OrderByPipe._orderBy = function (a, b) {
if (a instanceof Date && b instanceof Date) {
return a < b ? -1 : a > b ? 1 : 0;
}
var floatA = parseFloat(a);
var floatB = parseFloat(b);
if (typeof a === 'string' && typeof b === 'string' && (isNaN(floatA) || isNaN(floatB))) {
var lowerA = a.toLowerCase();
var lowerB = b.toLowerCase();
return lowerA < lowerB ? -1 : lowerA > lowerB ? 1 : 0;
}
return floatA < floatB ? -1 : floatA > floatB ? 1 : 0;
};
OrderByPipe.prototype.transform = function (input, config) {
if (config === void 0) { config = '+'; }
if (!isArray(input)) {
return input;
}
var configIsArray = isArray(config);
// If config === 'param' OR ['param']
if (!configIsArray || (configIsArray && config.length === 1)) {
var propertyToCheck = configIsArray ? config[0] : config;
var first = propertyToCheck.substr(0, 1);
var desc_1 = first === '-'; // First character is '-'
// Basic array (if only + or - is present)
if (!propertyToCheck || propertyToCheck === '-' || propertyToCheck === '+') {
return __spread(input).sort(function (a, b) {
var comparator = OrderByPipe_1._orderBy(a, b);
return desc_1 ? -comparator : comparator;
});
}
else {
// If contains + or -, substring the property
var property_1 = first === '+' || desc_1 ? propertyToCheck.substr(1) : propertyToCheck;
return __spread(input).sort(function (a, b) {
var comparator = OrderByPipe_1._orderBy(a[property_1], b[property_1]);
return desc_1 ? -comparator : comparator;
});
}
}
else {
// Config is an array of property
return __spread(input).sort(function (a, b) {
for (var i = 0; i < config.length; ++i) {
var first = config[i].substr(0, 1);
var desc = first === '-';
var property = first === '+' || desc ? config[i].substr(1) : config[i];
var comparator = OrderByPipe_1._orderBy(a[property], b[property]);
var comparison = desc ? -comparator : comparator;
if (comparison !== 0) {
return comparison;
}
}
return 0;
});
}
};
var OrderByPipe_1;
OrderByPipe = OrderByPipe_1 = __decorate([
core.Pipe({
name: 'orderBy',
})
], OrderByPipe);
return OrderByPipe;
}());
var NgOrderByPipeModule = /** @class */ (function () {
function NgOrderByPipeModule() {
}
NgOrderByPipeModule = __decorate([
core.NgModule({
declarations: [OrderByPipe],
exports: [OrderByPipe],
})
], NgOrderByPipeModule);
return NgOrderByPipeModule;
}());
var CountPipe = /** @class */ (function () {
function CountPipe() {
}
CountPipe.prototype.transform = function (input) {
return count(input);
};
CountPipe = __decorate([
core.Pipe({
name: 'count',
})
], CountPipe);
return CountPipe;
}());
var NgCountPipeModule = /** @class */ (function () {
function NgCountPipeModule() {
}
NgCountPipeModule = __decorate([
core.NgModule({
declarations: [CountPipe],
exports: [CountPipe],
})
], NgCountPipeModule);
return NgCountPipeModule;
}());
var SomePipe = /** @class */ (function () {
function SomePipe() {
}
SomePipe.prototype.transform = function (input, predicate) {
if (!isArray(input) || !predicate) {
return input;
}
var result = false;
var i = -1;
while (++i < input.length && !result) {
result = predicate(input[i], i, input);
}
return result;
};
SomePipe = __decorate([
core.Pipe({
name: 'some',
})
], SomePipe);
return SomePipe;
}());
var NgSomePipeModule = /** @class */ (function () {
function NgSomePipeModule() {
}
NgSomePipeModule = __decorate([
core.NgModule({
declarations: [SomePipe],
exports: [SomePipe],
})
], NgSomePipeModule);
return NgSomePipeModule;
}());
var EveryPipe = /** @class */ (function () {
function EveryPipe() {
}
EveryPipe.prototype.transform = function (input, predicate) {
return every(input, predicate);
};
EveryPipe = __decorate([
core.Pipe({
name: 'every',
})
], EveryPipe);
return EveryPipe;
}());
var NgEveryPipeModule = /** @class */ (function () {
function NgEveryPipeModule() {
}
NgEveryPipeModule = __decorate([
core.NgModule({
declarations: [EveryPipe],
exports: [EveryPipe],
})
], NgEveryPipeModule);
return NgEveryPipeModule;
}());
var ShufflePipe = /** @class */ (function () {
function ShufflePipe() {
}
ShufflePipe.prototype.transform = function (input) {
return shuffle(input);
};
ShufflePipe = __decorate([
core.Pipe({
name: 'shuffle',
})
], ShufflePipe);
return ShufflePipe;
}());
var NgShufflePipeModule = /** @class */ (function () {
function NgShufflePipeModule() {
}
NgShufflePipeModule = __decorate([
core.NgModule({
declarations: [ShufflePipe],
exports: [ShufflePipe],
})
], NgShufflePipeModule);
return NgShufflePipeModule;
}());
var TakePipe = /** @class */ (function () {
function TakePipe() {
}
TakePipe.prototype.transform = function (input, quantity) {
if (!isArray(input)) {
return input;
}
return input.slice(0, quantity || 1);
};
TakePipe = __decorate([
core.Pipe({
name: 'take',
})
], TakePipe);
return TakePipe;
}());
var NgTakePipeModule = /** @class */ (function () {
function NgTakePipeModule() {
}
NgTakePipeModule = __decorate([
core.NgModule({
declarations: [TakePipe],
exports: [TakePipe],
})
], NgTakePipeModule);
return NgTakePipeModule;
}());
var DropPipe = /** @class */ (function () {
function DropPipe() {
}
DropPipe.prototype.transform = function (input, quantity) {
if (!isArray(input)) {
return input;
}
return input.slice(quantity || 1, input.lenth);
};
DropPipe = __decorate([
core.Pipe({
name: 'drop',
})
], DropPipe);
return DropPipe;
}());
var NgDropPipeModule = /** @class */ (function () {
function NgDropPipeModule() {
}
NgDropPipeModule = __decorate([
core.NgModule({
declarations: [DropPipe],
exports: [DropPipe],
})
], NgDropPipeModule);
return NgDropPipeModule;
}());
var DeepPipe = /** @class */ (function () {
function DeepPipe() {
}
DeepPipe.prototype.transform = function (value) {
if (isDeepObject(value)) {
return value;
}
return wrapDeep(value);
};
DeepPipe = __decorate([
core.Pipe({
name: 'deep',
})
], DeepPipe);
return DeepPipe;
}());
var NgDeepPipeModule = /** @class */ (function () {
function NgDeepPipeModule() {
}
NgDeepPipeModule = __decorate([
core.NgModule({
declarations: [DeepPipe],
exports: [DeepPipe],
})
], NgDeepPipeModule);
return NgDeepPipeModule;
}());
var ChunkPipe = /** @class */ (function () {
function ChunkPipe() {
}
ChunkPipe.prototype.transform = function (input, size) {
if (size === void 0) { size = 1; }
if (!isArray(input)) {
return input;
}
return [].concat.apply([], input.map(function (_elem, i) {
return i % size ? [] : [input.slice(i, i + size)];
}));
};
ChunkPipe = __decorate([
core.Pipe({
name: 'chunk',
})
], ChunkPipe);
return ChunkPipe;
}());
var NgChunkPipeModule = /** @class */ (function () {
function NgChunkPipeModule() {
}
NgChunkPipeModule = __decorate([
core.NgModule({
declarations: [ChunkPipe],
exports: [ChunkPipe],
})
], NgChunkPipeModule);
return NgChunkPipeModule;
}());
var FlattenPipe = /** @class */ (function () {
function FlattenPipe() {
}
FlattenPipe.prototype.transform = function (input) {
var isDeep = isDeepObject(input);
if (!isArray(input) && !isDeep) {
return input;
}
if (isDeep) {
var unwrapped = unwrapDeep(input);
if (!isArray(unwrapped)) {
return unwrapped;
}
return flatten(unwrapped, 0);
}
return [].concat.apply([], input);
};
FlattenPipe = __decorate([
core.Pipe({ name: 'flatten' })
], FlattenPipe);
return FlattenPipe;
}());
var NgFlattenPipeModule = /** @class */ (function () {
function NgFlattenPipeModule() {
}
NgFlattenPipeModule = __decorate([
core.NgModule({
declarations: [FlattenPipe],
exports: [FlattenPipe],
})
], NgFlattenPipeModule);
return NgFlattenPipeModule;
}());
var IntersectionPipe = /** @class */ (function () {
function IntersectionPipe() {
}
IntersectionPipe.prototype.transform = function (a, b) {
if ((!isArray(a) && !isDeepObject(a)) || !isArray(b)) {
return [];
}
if (isDeepObject(a)) {
var unwrapped = unwrapDeep(a);
if (!isArray(unwrapped)) {
return [];
}
return unwrapped.reduce(function (intersection, value) {
return intersection.concat(deepIndexOf(b, value) !== -1 && deepIndexOf(intersection, value) === -1 ? value : []);
}, []);
}
return a.reduce(function (intersection, value) {
return intersection.concat(b.indexOf(value) !== -1 && intersection.indexOf(value) === -1 ? value : []);
}, []);
};
IntersectionPipe = __decorate([
core.Pipe({
name: 'intersection',
})
], IntersectionPipe);
return IntersectionPipe;
}());
var NgIntersectionPipeModule = /** @class */ (function () {
function NgIntersectionPipeModule() {
}
NgIntersectionPipeModule = __decorate([
core.NgModule({
declarations: [IntersectionPipe],
exports: [IntersectionPipe],
})
], NgIntersectionPipeModule);
return NgIntersectionPipeModule;
}());
var UnionPipe = /** @class */ (function () {
function UnionPipe() {
}
UnionPipe.prototype.transform = function (a, b) {
if ((!isArray(a) && !isDeepObject(a)) || !isArray(b)) {
return [];
}
if (isDeepObject(a)) {
var unwrapped = unwrapDeep(a);
if (!isArray(unwrapped)) {
return [];
}
return []
.concat(unwrapped)
.concat(b)
.filter(function (value, index, input) { return deepIndexOf(input, value) === index; });
}
return []
.concat(a)
.concat(b)
.filter(function (value, index, input) { return input.indexOf(value) === index; });
};
UnionPipe = __decorate([
core.Pipe({
name: 'union',
})
], UnionPipe);
return UnionPipe;
}());
var NgUnionPipeModule = /** @class */ (function () {
function NgUnionPipeModule() {
}
NgUnionPipeModule = __decorate([
core.NgModule({
declarations: [UnionPipe],
exports: [UnionPipe],
})
], NgUnionPipeModule);
return NgUnionPipeModule;
}());
var TakeWhilePipe = /** @class */ (function () {
function TakeWhilePipe() {
}
TakeWhilePipe.prototype.transform = function (input, predicate) {
if (!isArray(input) || isNil(predicate)) {
return input;
}
return takeWhile(input, predicate);
};
TakeWhilePipe = __decorate([
core.Pipe({
name: 'takeWhile',
})
], TakeWhilePipe);
return TakeWhilePipe;
}());
var NgTakeWhilePipeModule = /** @class */ (function () {
function NgTakeWhilePipeModule() {
}
NgTakeWhilePipeModule = __decorate([
core.NgModule({
declarations: [TakeWhilePipe],
exports: [TakeWhilePipe],
})
], NgTakeWhilePipeModule);
return NgTakeWhilePipeModule;
}());
var TakeUntilPipe = /** @class */ (function () {
function TakeUntilPipe() {
}
TakeUntilPipe.prototype.transform = function (input, predicate) {
if (!isArray(input) || isNil(predicate)) {
return input;
}
return takeUntil(input, predicate);
};
TakeUntilPipe = __decorate([
core.Pipe({
name: 'takeUntil',
})
], TakeUntilPipe);
return TakeUntilPipe;
}());
var NgTakeUntilPipeModule = /** @class */ (function () {
function NgTakeUntilPipeModule() {
}
NgTakeUntilPipeModule = __decorate([
core.NgModule({
declarations: [TakeUntilPipe],
exports: [TakeUntilPipe],
})
], NgTakeUntilPipeModule);
return NgTakeUntilPipeModule;
}());
var NgArrayPipesModule = /** @class */ (function () {
function NgArrayPipesModule() {
}
NgArrayPipesModule = __decorate([
core.NgModule({
imports: [
NgChunkPipeModule,
NgCountPipeModule,
NgDeepPipeModule,
NgDropPipeModule,
NgEmptyPipeModule,
NgEveryPipeModule,
NgFirstOrDefaultPipeModule,
NgFlattenPipeModule,
NgHeadPipeModule,
NgInitialPipeModule,
NgIntersectionPipeModule,
NgJoinPipeModule,
NgLastPipeModule,
NgMapPipeModule,
NgOrderByPipeModule,
NgPluckPipeModule,
NgRangePipeModule,
NgReversePipeModule,
NgShufflePipeModule,
NgSomePipeModule,
NgTailPipeModule,
NgTakeUntilPipeModule,
NgTakeWhilePipeModule,
NgTakePipeModule,
NgUnionPipeModule,
NgUniqPipeModule,
NgWherePipeModule,
NgWithoutPipeModule,
],
})
], NgArrayPipesModule);
return NgArrayPipesModule;
}());
var IsEqualPipe = /** @class */ (function () {
function IsEqualPipe() {
}
IsEqualPipe.prototype.transform = function (first, second) {
return first == second;
};
IsEqualPipe = __decorate([
core.Pipe({
name: 'equal',
})
], IsEqualPipe);
return IsEqualPipe;
}());
var NgIsEqualPipeModule = /** @class */ (function () {
function NgIsEqualPipeModule() {
}
NgIsEqualPipeModule = __decorate([
core.NgModule({
declarations: [IsEqualPipe],
exports: [IsEqualPipe],
})
], NgIsEqualPipeModule);
return NgIsEqualPipeModule;
}());
var IsGreaterOrEqualPipe = /**