jinaga/dist/util/fn.js

Data management for web and mobile applications.

"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.distinct = exports.findIndex = exports.filterAsync = exports.mapAsync = exports.flatten = exports.flattenAsync = void 0;
function safeFlatten(results) {
    const flat = results.reduce((a, b) => (!a || a.length === 0) ? b :
        (!b || b.length === 0) ? a :
            a.concat(b));
    return flat ? flat : [];
}
function flattenAsync(collection, selector) {
    return __awaiter(this, void 0, void 0, function* () {
        if (collection.length === 0) {
            return [];
        }
        else {
            const results = yield Promise.all(collection.map(selector));
            return safeFlatten(results);
        }
    });
}
exports.flattenAsync = flattenAsync;
function flatten(collection, selector) {
    if (collection.length === 0) {
        return [];
    }
    else {
        return safeFlatten(collection.map(selector));
    }
}
exports.flatten = flatten;
function mapAsync(collection, action) {
    return __awaiter(this, void 0, void 0, function* () {
        if (collection.length === 0) {
            return [];
        }
        else {
            return yield Promise.all(collection.map(action));
        }
    });
}
exports.mapAsync = mapAsync;
function filterAsync(collection, predicate) {
    return __awaiter(this, void 0, void 0, function* () {
        if (collection.length === 0) {
            return [];
        }
        else {
            const filters = yield Promise.all(collection.map((element) => __awaiter(this, void 0, void 0, function* () {
                return ({
                    include: yield predicate(element),
                    element
                });
            })));
            return filters.filter(f => f.include).map(f => f.element);
        }
    });
}
exports.filterAsync = filterAsync;
function findIndex(array, predicate) {
    for (let index = 0; index < array.length; index++) {
        if (predicate(array[index])) {
            return index;
        }
    }
    return -1;
}
exports.findIndex = findIndex;
function distinct(value, index, self) {
    return self.indexOf(value) === index;
}
exports.distinct = distinct;
//# sourceMappingURL=fn.js.map