@ashetm/ng-utility/fesm2022/ashetm-ng-utility.mjs

``@ashetm/ng-utility`` is a library that provide some utilities classes, like pipes.

import * as i0 from '@angular/core';
import { Pipe, NgModule } from '@angular/core';
import { coerceBooleanProperty } from '@angular/cdk/coercion';
import { map } from 'rxjs/operators';

class ArrayFill {
    transform(list, value) {
        return list.fill(value);
    }
    static { this.ɵfac = function ArrayFill_Factory(t) { return new (t || ArrayFill)(); }; }
    static { this.ɵpipe = /*@__PURE__*/ i0.ɵɵdefinePipe({ name: "arrayFill", type: ArrayFill, pure: true, standalone: true }); }
}
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ArrayFill, [{
        type: Pipe,
        args: [{
                name: 'arrayFill',
                standalone: true
            }]
    }], null, null); })();

class ArrayFilter {
    transform(value, filterBy, key) {
        return value.filter((val) => {
            return filterBy === undefined
                || (String(typeof val === 'object' && key ? val[key] : val)).includes(String(filterBy));
        });
    }
    static { this.ɵfac = function ArrayFilter_Factory(t) { return new (t || ArrayFilter)(); }; }
    static { this.ɵpipe = /*@__PURE__*/ i0.ɵɵdefinePipe({ name: "arrayFilter", type: ArrayFilter, pure: true, standalone: true }); }
}
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ArrayFilter, [{
        type: Pipe,
        args: [{
                name: 'arrayFilter',
                standalone: true
            }]
    }], null, null); })();

class ArrayFrom {
    transform(length, fill) {
        return Array.from({ length }, (_, i) => fill ?? i);
    }
    static { this.ɵfac = function ArrayFrom_Factory(t) { return new (t || ArrayFrom)(); }; }
    static { this.ɵpipe = /*@__PURE__*/ i0.ɵɵdefinePipe({ name: "arrayFrom", type: ArrayFrom, pure: true, standalone: true }); }
}
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ArrayFrom, [{
        type: Pipe,
        args: [{
                name: 'arrayFrom',
                standalone: true
            }]
    }], null, null); })();

class ArrayIncludes {
    transform(list, value) {
        return list.includes(value);
    }
    static { this.ɵfac = function ArrayIncludes_Factory(t) { return new (t || ArrayIncludes)(); }; }
    static { this.ɵpipe = /*@__PURE__*/ i0.ɵɵdefinePipe({ name: "arrayIncludes", type: ArrayIncludes, pure: true, standalone: true }); }
}
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ArrayIncludes, [{
        type: Pipe,
        args: [{
                name: 'arrayIncludes',
                standalone: true
            }]
    }], null, null); })();

class ArrayPluck {
    transform(value, key) {
        return value.map((o) => o[key]).filter(Boolean);
    }
    static { this.ɵfac = function ArrayPluck_Factory(t) { return new (t || ArrayPluck)(); }; }
    static { this.ɵpipe = /*@__PURE__*/ i0.ɵɵdefinePipe({ name: "arrayPluck", type: ArrayPluck, pure: true, standalone: true }); }
}
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ArrayPluck, [{
        type: Pipe,
        args: [{
                name: 'arrayPluck',
                standalone: true
            }]
    }], null, null); })();

class ArrayPop {
    transform(list) {
        return list.length === 0 ? list.pop() : undefined;
    }
    static { this.ɵfac = function ArrayPop_Factory(t) { return new (t || ArrayPop)(); }; }
    static { this.ɵpipe = /*@__PURE__*/ i0.ɵɵdefinePipe({ name: "arrayPop", type: ArrayPop, pure: true, standalone: true }); }
}
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ArrayPop, [{
        type: Pipe,
        args: [{
                name: 'arrayPop',
                standalone: true
            }]
    }], null, null); })();

class ArrayShuffle {
    transform(array) {
        let currentIndex = array.length, randomIndex, tempValue;
        while (currentIndex !== 0) {
            randomIndex = Math.floor(Math.random() * currentIndex);
            currentIndex--;
            tempValue = array[currentIndex];
            array[currentIndex] = array[randomIndex];
            array[randomIndex] = tempValue;
        }
        return array;
    }
    static { this.ɵfac = function ArrayShuffle_Factory(t) { return new (t || ArrayShuffle)(); }; }
    static { this.ɵpipe = /*@__PURE__*/ i0.ɵɵdefinePipe({ name: "arrayShuffle", type: ArrayShuffle, pure: true, standalone: true }); }
}
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ArrayShuffle, [{
        type: Pipe,
        args: [{
                name: 'arrayShuffle',
                standalone: true,
            }]
    }], null, null); })();

class ArraySort {
    transform(list, direction = 'asc', key) {
        return list.sort((item1, item2) => {
            return ((key ? (item1[key] > item2[key]) : (item1 > item2)) ? -1 : 1) * (direction === 'asc' ? 1 : -1);
        });
    }
    static { this.ɵfac = function ArraySort_Factory(t) { return new (t || ArraySort)(); }; }
    static { this.ɵpipe = /*@__PURE__*/ i0.ɵɵdefinePipe({ name: "arraySort", type: ArraySort, pure: true, standalone: true }); }
}
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ArraySort, [{
        type: Pipe,
        args: [{
                name: 'arraySort',
                standalone: true
            }]
    }], null, null); })();

class ArraySortAsc extends ArraySort {
    transform(list, key) {
        return super.transform(list, 'asc', key);
    }
    static { this.ɵfac = /*@__PURE__*/ function () { let ɵArraySortAsc_BaseFactory; return function ArraySortAsc_Factory(t) { return (ɵArraySortAsc_BaseFactory || (ɵArraySortAsc_BaseFactory = i0.ɵɵgetInheritedFactory(ArraySortAsc)))(t || ArraySortAsc); }; }(); }
    static { this.ɵpipe = /*@__PURE__*/ i0.ɵɵdefinePipe({ name: "arraySortAsc", type: ArraySortAsc, pure: true, standalone: true }); }
}
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ArraySortAsc, [{
        type: Pipe,
        args: [{
                name: 'arraySortAsc',
                standalone: true
            }]
    }], null, null); })();

class ArraySortDesc extends ArraySort {
    transform(list, key) {
        return super.transform(list, 'desc', key);
    }
    static { this.ɵfac = /*@__PURE__*/ function () { let ɵArraySortDesc_BaseFactory; return function ArraySortDesc_Factory(t) { return (ɵArraySortDesc_BaseFactory || (ɵArraySortDesc_BaseFactory = i0.ɵɵgetInheritedFactory(ArraySortDesc)))(t || ArraySortDesc); }; }(); }
    static { this.ɵpipe = /*@__PURE__*/ i0.ɵɵdefinePipe({ name: "arraySortDesc", type: ArraySortDesc, pure: true, standalone: true }); }
}
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ArraySortDesc, [{
        type: Pipe,
        args: [{
                name: 'arraySortDesc',
                standalone: true
            }]
    }], null, null); })();

class CapitalCase {
    transform(value) {
        return value[0].toUpperCase() + value.substr(1).toLowerCase();
    }
    static { this.ɵfac = function CapitalCase_Factory(t) { return new (t || CapitalCase)(); }; }
    static { this.ɵpipe = /*@__PURE__*/ i0.ɵɵdefinePipe({ name: "capitalCase", type: CapitalCase, pure: true, standalone: true }); }
}
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(CapitalCase, [{
        type: Pipe,
        args: [{
                name: 'capitalCase',
                standalone: true
            }]
    }], null, null); })();

class CoerciveBoolean {
    transform(value) {
        return coerceBooleanProperty(value);
    }
    static { this.ɵfac = function CoerciveBoolean_Factory(t) { return new (t || CoerciveBoolean)(); }; }
    static { this.ɵpipe = /*@__PURE__*/ i0.ɵɵdefinePipe({ name: "coerciveBoolean", type: CoerciveBoolean, pure: true, standalone: true }); }
}
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(CoerciveBoolean, [{
        type: Pipe,
        args: [{
                name: 'coerciveBoolean',
                standalone: true
            }]
    }], null, null); })();

class ControlErrors {
    transform({ errors }) {
        const errorsControl = errors || {};
        let messages = [];
        for (const key in errorsControl) {
            switch (true) {
                case key === 'required':
                    messages = [...messages, 'This field is required'];
                    break;
                case typeof errorsControl[key] === 'string':
                default:
                    messages = [...messages, errorsControl[key]];
            }
        }
        return messages;
    }
    static { this.ɵfac = function ControlErrors_Factory(t) { return new (t || ControlErrors)(); }; }
    static { this.ɵpipe = /*@__PURE__*/ i0.ɵɵdefinePipe({ name: "controlErrors", type: ControlErrors, pure: true, standalone: true }); }
}
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ControlErrors, [{
        type: Pipe,
        args: [{
                name: 'controlErrors',
                standalone: true
            }]
    }], null, null); })();

class ControlValue {
    transform(value) {
        return value?.getRawValue();
    }
    static { this.ɵfac = function ControlValue_Factory(t) { return new (t || ControlValue)(); }; }
    static { this.ɵpipe = /*@__PURE__*/ i0.ɵɵdefinePipe({ name: "controlValue", type: ControlValue, pure: true, standalone: true }); }
}
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ControlValue, [{
        type: Pipe,
        args: [{
                name: 'controlValue',
                standalone: true
            }]
    }], null, null); })();

class DateMax {
    transform(value) {
        const dateTimestampList = value.map((item) => new Date(item).getTime());
        const maxDate = Math.max(...dateTimestampList);
        return new Date(maxDate);
    }
    static { this.ɵfac = function DateMax_Factory(t) { return new (t || DateMax)(); }; }
    static { this.ɵpipe = /*@__PURE__*/ i0.ɵɵdefinePipe({ name: "dateMax", type: DateMax, pure: true, standalone: true }); }
}
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(DateMax, [{
        type: Pipe,
        args: [{
                name: 'dateMax',
                standalone: true
            }]
    }], null, null); })();

class DateMin {
    transform(value) {
        const dateTimestampList = value.map((item) => new Date(item).getTime());
        const maxDate = Math.max(...dateTimestampList);
        return new Date(maxDate);
    }
    static { this.ɵfac = function DateMin_Factory(t) { return new (t || DateMin)(); }; }
    static { this.ɵpipe = /*@__PURE__*/ i0.ɵɵdefinePipe({ name: "dateMin", type: DateMin, pure: true, standalone: true }); }
}
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(DateMin, [{
        type: Pipe,
        args: [{
                name: 'dateMin',
                standalone: true
            }]
    }], null, null); })();

class Format {
    constructor() {
        this.PLACEHOLDER_CHARACTER = '*';
    }
    transform(value, mask) {
        const stringifiedValue = String(value);
        let valueIndex = 0;
        let result = '';
        for (let i = 0; i < mask.length; i++) {
            const charater = mask[i];
            if (charater === this.PLACEHOLDER_CHARACTER) {
                result += stringifiedValue[valueIndex] || '';
                valueIndex++;
            }
            else {
                result += mask[i];
            }
        }
        return result;
    }
    static { this.ɵfac = function Format_Factory(t) { return new (t || Format)(); }; }
    static { this.ɵpipe = /*@__PURE__*/ i0.ɵɵdefinePipe({ name: "format", type: Format, pure: true, standalone: true }); }
}
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(Format, [{
        type: Pipe,
        args: [{
                name: 'format',
                standalone: true
            }]
    }], null, null); })();

class Initial {
    transform(value, max = Infinity) {
        return value.split(' ').map((word) => {
            return word[0].toUpperCase();
        }).filter((_, index) => index < max)
            .join('');
    }
    static { this.ɵfac = function Initial_Factory(t) { return new (t || Initial)(); }; }
    static { this.ɵpipe = /*@__PURE__*/ i0.ɵɵdefinePipe({ name: "initial", type: Initial, pure: true, standalone: true }); }
}
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(Initial, [{
        type: Pipe,
        args: [{
                name: 'initial',
                standalone: true
            }]
    }], null, null); })();

class IsArray {
    transform(value) {
        return Array.isArray(value);
    }
    static { this.ɵfac = function IsArray_Factory(t) { return new (t || IsArray)(); }; }
    static { this.ɵpipe = /*@__PURE__*/ i0.ɵɵdefinePipe({ name: "isArray", type: IsArray, pure: true, standalone: true }); }
}
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(IsArray, [{
        type: Pipe,
        args: [{
                name: 'isArray',
                standalone: true
            }]
    }], null, null); })();

class IsDate {
    transform(value) {
        return this.isDate(value);
    }
    isDate(value) {
        return value && !isNaN(new Date(value).getTime());
    }
    static { this.ɵfac = function IsDate_Factory(t) { return new (t || IsDate)(); }; }
    static { this.ɵpipe = /*@__PURE__*/ i0.ɵɵdefinePipe({ name: "isDate", type: IsDate, pure: true, standalone: true }); }
}
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(IsDate, [{
        type: Pipe,
        args: [{
                name: 'isDate',
                standalone: true
            }]
    }], null, null); })();

class IsDateAfter extends IsDate {
    transform(value, dateAfter) {
        if (!super.isDate(value))
            return false;
        return new Date(value).getTime() > new Date(dateAfter).getTime();
    }
    static { this.ɵfac = /*@__PURE__*/ function () { let ɵIsDateAfter_BaseFactory; return function IsDateAfter_Factory(t) { return (ɵIsDateAfter_BaseFactory || (ɵIsDateAfter_BaseFactory = i0.ɵɵgetInheritedFactory(IsDateAfter)))(t || IsDateAfter); }; }(); }
    static { this.ɵpipe = /*@__PURE__*/ i0.ɵɵdefinePipe({ name: "isDateAfter", type: IsDateAfter, pure: true, standalone: true }); }
}
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(IsDateAfter, [{
        type: Pipe,
        args: [{
                name: 'isDateAfter',
                standalone: true
            }]
    }], null, null); })();

class IsDateBefore extends IsDate {
    transform(value, dateBefore) {
        if (!super.isDate(value))
            return false;
        return new Date(value).getTime() < new Date(dateBefore).getTime();
    }
    static { this.ɵfac = /*@__PURE__*/ function () { let ɵIsDateBefore_BaseFactory; return function IsDateBefore_Factory(t) { return (ɵIsDateBefore_BaseFactory || (ɵIsDateBefore_BaseFactory = i0.ɵɵgetInheritedFactory(IsDateBefore)))(t || IsDateBefore); }; }(); }
    static { this.ɵpipe = /*@__PURE__*/ i0.ɵɵdefinePipe({ name: "isDateBefore", type: IsDateBefore, pure: true, standalone: true }); }
}
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(IsDateBefore, [{
        type: Pipe,
        args: [{
                name: 'isDateBefore',
                standalone: true
            }]
    }], null, null); })();

class IsDateBetween extends IsDate {
    transform(value, interval, max) {
        if (super.isDate(value)) {
            return false;
        }
        const [minDate, maxDate] = Array.isArray(interval)
            ? [
                new Date(interval[0]),
                new Date(interval[1])
            ]
            : [
                new Date(interval),
                new Date(max)
            ];
        const date = new Date(value).getTime();
        return minDate.getTime() < date && maxDate.getTime() > date;
    }
    static { this.ɵfac = /*@__PURE__*/ function () { let ɵIsDateBetween_BaseFactory; return function IsDateBetween_Factory(t) { return (ɵIsDateBetween_BaseFactory || (ɵIsDateBetween_BaseFactory = i0.ɵɵgetInheritedFactory(IsDateBetween)))(t || IsDateBetween); }; }(); }
    static { this.ɵpipe = /*@__PURE__*/ i0.ɵɵdefinePipe({ name: "isDateBetween", type: IsDateBetween, pure: true, standalone: true }); }
}
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(IsDateBetween, [{
        type: Pipe,
        args: [{
                name: 'isDateBetween',
                standalone: true
            }]
    }], null, null); })();

class IsDateFuture extends IsDateAfter {
    transform(value) {
        return super.transform(value, Date.now());
    }
    static { this.ɵfac = /*@__PURE__*/ function () { let ɵIsDateFuture_BaseFactory; return function IsDateFuture_Factory(t) { return (ɵIsDateFuture_BaseFactory || (ɵIsDateFuture_BaseFactory = i0.ɵɵgetInheritedFactory(IsDateFuture)))(t || IsDateFuture); }; }(); }
    static { this.ɵpipe = /*@__PURE__*/ i0.ɵɵdefinePipe({ name: "isDateFuture", type: IsDateFuture, pure: true, standalone: true }); }
}
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(IsDateFuture, [{
        type: Pipe,
        args: [{
                name: 'isDateFuture',
                standalone: true
            }]
    }], null, null); })();

class IsDatePast extends IsDateBefore {
    transform(value) {
        return super.transform(value, Date.now());
    }
    static { this.ɵfac = /*@__PURE__*/ function () { let ɵIsDatePast_BaseFactory; return function IsDatePast_Factory(t) { return (ɵIsDatePast_BaseFactory || (ɵIsDatePast_BaseFactory = i0.ɵɵgetInheritedFactory(IsDatePast)))(t || IsDatePast); }; }(); }
    static { this.ɵpipe = /*@__PURE__*/ i0.ɵɵdefinePipe({ name: "isDatePast", type: IsDatePast, pure: true, standalone: true }); }
}
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(IsDatePast, [{
        type: Pipe,
        args: [{
                name: 'isDatePast',
                standalone: true
            }]
    }], null, null); })();

class Log {
    transform(value, type = 'log') {
        console[type](value);
        return value;
    }
    static { this.ɵfac = function Log_Factory(t) { return new (t || Log)(); }; }
    static { this.ɵpipe = /*@__PURE__*/ i0.ɵɵdefinePipe({ name: "log", type: Log, pure: true, standalone: true }); }
}
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(Log, [{
        type: Pipe,
        args: [{
                name: 'log',
                standalone: true
            }]
    }], null, null); })();

class ObjectEntries {
    transform(value) {
        return Object.entries(value);
    }
    static { this.ɵfac = function ObjectEntries_Factory(t) { return new (t || ObjectEntries)(); }; }
    static { this.ɵpipe = /*@__PURE__*/ i0.ɵɵdefinePipe({ name: "objectEntries", type: ObjectEntries, pure: true, standalone: true }); }
}
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ObjectEntries, [{
        type: Pipe,
        args: [{
                name: 'objectEntries',
                standalone: true
            }]
    }], null, null); })();

class ObjectKeys {
    transform(value) {
        return Object.keys(value);
    }
    static { this.ɵfac = function ObjectKeys_Factory(t) { return new (t || ObjectKeys)(); }; }
    static { this.ɵpipe = /*@__PURE__*/ i0.ɵɵdefinePipe({ name: "objectKeys", type: ObjectKeys, pure: true, standalone: true }); }
}
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ObjectKeys, [{
        type: Pipe,
        args: [{
                name: 'objectKeys',
                standalone: true
            }]
    }], null, null); })();

class ObjectValues {
    transform(value) {
        return Object.values(value);
    }
    static { this.ɵfac = function ObjectValues_Factory(t) { return new (t || ObjectValues)(); }; }
    static { this.ɵpipe = /*@__PURE__*/ i0.ɵɵdefinePipe({ name: "objectValues", type: ObjectValues, pure: true, standalone: true }); }
}
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ObjectValues, [{
        type: Pipe,
        args: [{
                name: 'objectValues',
                standalone: true
            }]
    }], null, null); })();

class UtilityPipesModule {
    static { this.ɵfac = function UtilityPipesModule_Factory(t) { return new (t || UtilityPipesModule)(); }; }
    static { this.ɵmod = /*@__PURE__*/ i0.ɵɵdefineNgModule({ type: UtilityPipesModule }); }
    static { this.ɵinj = /*@__PURE__*/ i0.ɵɵdefineInjector({}); }
}
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(UtilityPipesModule, [{
        type: NgModule,
        args: [{
                exports: [
                    ArrayFill,
                    ArrayFilter,
                    ArrayFrom,
                    ArrayIncludes,
                    ArrayPluck,
                    ArrayPop,
                    ArrayShuffle,
                    ArraySort,
                    ArraySortAsc,
                    ArraySortDesc,
                    CapitalCase,
                    CoerciveBoolean,
                    ControlErrors,
                    ControlValue,
                    Format,
                    Initial,
                    IsDate,
                    IsDateAfter,
                    IsDateBefore,
                    IsDateBetween,
                    IsDateFuture,
                    IsDatePast,
                    Log,
                    ObjectEntries,
                    ObjectKeys,
                    ObjectValues,
                ],
                imports: [
                    ArrayFill,
                    ArrayFilter,
                    ArrayFrom,
                    ArrayIncludes,
                    ArrayPluck,
                    ArrayPop,
                    ArrayShuffle,
                    ArraySort,
                    ArraySortAsc,
                    ArraySortDesc,
                    CapitalCase,
                    CoerciveBoolean,
                    ControlErrors,
                    ControlValue,
                    Format,
                    Initial,
                    IsDate,
                    IsDateAfter,
                    IsDateBefore,
                    IsDateBetween,
                    IsDateFuture,
                    IsDatePast,
                    Log,
                    ObjectEntries,
                    ObjectKeys,
                    ObjectValues,
                ],
            }]
    }], null, null); })();
(function () { (typeof ngJitMode === "undefined" || ngJitMode) && i0.ɵɵsetNgModuleScope(UtilityPipesModule, { imports: [ArrayFill,
        ArrayFilter,
        ArrayFrom,
        ArrayIncludes,
        ArrayPluck,
        ArrayPop,
        ArrayShuffle,
        ArraySort,
        ArraySortAsc,
        ArraySortDesc,
        CapitalCase,
        CoerciveBoolean,
        ControlErrors,
        ControlValue,
        Format,
        Initial,
        IsDate,
        IsDateAfter,
        IsDateBefore,
        IsDateBetween,
        IsDateFuture,
        IsDatePast,
        Log,
        ObjectEntries,
        ObjectKeys,
        ObjectValues], exports: [ArrayFill,
        ArrayFilter,
        ArrayFrom,
        ArrayIncludes,
        ArrayPluck,
        ArrayPop,
        ArrayShuffle,
        ArraySort,
        ArraySortAsc,
        ArraySortDesc,
        CapitalCase,
        CoerciveBoolean,
        ControlErrors,
        ControlValue,
        Format,
        Initial,
        IsDate,
        IsDateAfter,
        IsDateBefore,
        IsDateBetween,
        IsDateFuture,
        IsDatePast,
        Log,
        ObjectEntries,
        ObjectKeys,
        ObjectValues] }); })();

class UtilityModule {
    static { this.ɵfac = function UtilityModule_Factory(t) { return new (t || UtilityModule)(); }; }
    static { this.ɵmod = /*@__PURE__*/ i0.ɵɵdefineNgModule({ type: UtilityModule }); }
    static { this.ɵinj = /*@__PURE__*/ i0.ɵɵdefineInjector({ imports: [UtilityPipesModule] }); }
}
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(UtilityModule, [{
        type: NgModule,
        args: [{
                exports: [UtilityPipesModule]
            }]
    }], null, null); })();
(function () { (typeof ngJitMode === "undefined" || ngJitMode) && i0.ɵɵsetNgModuleScope(UtilityModule, { exports: [UtilityPipesModule] }); })();

function containsItem(fn) {
    return (source$) => source$.pipe(map((list) => list.some((item) => fn(item))));
}

function filterFromArray(fn) {
    return (source$) => source$.pipe(map((list) => list.filter((item, index) => fn(item, index))));
}

function nthFromArray(index) {
    return (source$) => source$.pipe(map((list) => list[index]));
}

function firstFromArray() {
    return nthFromArray(0);
}

function lastFromArray() {
    return (source$) => source$.pipe(map((list) => list[list.length - 1]));
}

function mapFromArray(fn) {
    return (source$) => source$.pipe(map((list) => list.map((item) => fn(item))));
}

function pluckFromArray(key) {
    return (source$) => source$.pipe(map((list) => list.map((item) => item[key])));
}

/*
 * Public API Surface of ng-utility
 */

/**
 * Generated bundle index. Do not edit.
 */

export { ArrayFill, ArrayFilter, ArrayFrom, ArrayIncludes, ArrayPluck, ArrayPop, ArrayShuffle, ArraySort, ArraySortAsc, ArraySortDesc, CapitalCase, CoerciveBoolean, ControlErrors, ControlValue, DateMax, DateMin, Format, Initial, IsArray, IsDate, IsDateAfter, IsDateBefore, IsDateBetween, IsDateFuture, IsDatePast, Log, ObjectEntries, ObjectKeys, ObjectValues, UtilityModule, UtilityPipesModule, containsItem, filterFromArray, firstFromArray, lastFromArray, mapFromArray, nthFromArray, pluckFromArray };
//# sourceMappingURL=ashetm-ng-utility.mjs.map