bitfront-library/base/shared/utils.js

Angular CLI project with components and classes used by other Angular projects of the BIT foundation.

"use strict";
var __spreadArrays = (this && this.__spreadArrays) || function () {
    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
    for (var r = Array(s), k = 0, i = 0; i < il; i++)
        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
            r[k] = a[j];
    return r;
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.objectoToQueryParameters = exports.assign = exports.choose = exports.reject = exports.deleteElement = exports.upsertElement = void 0;
/**
 * Actualiza el elemento de la lista en caso de que exista en dicha lista, o lo inserta en caso de que no exista
 * @param element objeto que queremos actualizar o insertar en la lista
 * @param list lista de elementos
 */
function upsertElement(element, list) {
    var find = false;
    if (!list)
        list = [];
    list.forEach(function (item, index) {
        if (item.id == element.id) {
            list[index] = element;
            find = true;
        }
    });
    if (!find) {
        list.push(element);
    }
    return list;
}
exports.upsertElement = upsertElement;
/**
 * Elimina el elemento de la lista
 * @param element elemento a eliminar de la lista
 * @param list lista de elementos
 */
function deleteElement(element, list) {
    return list.filter(function (item) { return item.id != element.id; });
}
exports.deleteElement = deleteElement;
/** Permite copiar las propiedades de un objeto exceptuando las propiedades indicadas en keys.
 * Util para obtener los valores del filtro exceptuando las propiedades pagina y resultados.
 * La copia se realiza mediante Object.assign por lo que hay que tenerlo en cuenta por temas de propiedades anidadas
 * @param obj objeto que queremos copiar
 * @param keys array de propiedades que no queremos copiar
 */
function reject(obj, keys) {
    return Object.keys(obj)
        .filter(function (k) { return !keys.includes(k); })
        .map(function (k) {
        var _a;
        return Object.assign({}, (_a = {}, _a[k] = obj[k], _a));
    })
        .reduce(function (res, o) { return Object.assign(res, o); }, {});
}
exports.reject = reject;
/** Permite seleccionar las propiedades de un objeto indicadas en keys, excluyendo el resto.
 * La copia se realiza mediante Object.assign por lo que hay que tenerlo en cuenta por temas de propiedades anidadas
 * @param obj objeto que queremos copiar
 * @param keys array de propiedades que queremos copiar
 */
function choose(obj, keys) {
    return Object.keys(obj)
        .filter(function (k) { return keys.includes(k); })
        .map(function (k) {
        var _a;
        return Object.assign({}, (_a = {}, _a[k] = obj[k], _a));
    })
        .reduce(function (res, o) { return Object.assign(res, o); }, {});
}
exports.choose = choose;
/**
 * Equivalente al Object.assign() pero realiza una copia profunda: tanto los atributos como los objetos anidados
 * Modifica el objeto target asignando los objetos pasados como parámetros
 * ejemplo: assign({a: "a", b: {id: "b"}, c: "c"},
 *                 {a: "a2", b: {id: "b2"}, d: "d"}) =>
 *                 {a: "a2", b: {id: "b2"}, c: "c", d: "d"}
 *
 * @param target objeto destino
 * @param sources objetos cuyas propiedades se leen para mergear en el objeto destino
 * @see https://stackoverflow.com/questions/27936772/how-to-deep-merge-instead-of-shallow-merge
 */
function assign(target) {
    var sources = [];
    for (var _i = 1; _i < arguments.length; _i++) {
        sources[_i - 1] = arguments[_i];
    }
    var isObject = function (obj) { return obj && typeof obj === "object"; };
    if (!sources.length)
        return target;
    var source = sources.shift();
    if (isObject(target) && isObject(source)) {
        for (var key in source) {
            if (isObject(source[key])) {
                if (!target[key])
                    target[key] = {};
                assign(target[key], source[key]);
            }
            else {
                target[key] = source[key];
            }
        }
    }
    return assign.apply(void 0, __spreadArrays([target], sources));
}
exports.assign = assign;
function objectoToQueryParameters(params) {
    return Object.keys(params)
        .filter(function (key) { return !!params[key]; })
        .map(function (key) { return key + "=" + params[key]; })
        .join("&");
}
exports.objectoToQueryParameters = objectoToQueryParameters;
/*
Versión immutable:

export function assign(...objects) {
  const isObject = obj => obj && typeof obj === 'object';

  return objects.reduce((prev, obj) => {
    Object.keys(obj).forEach(key => {
      const pVal = prev[key];
      const oVal = obj[key];

      if (Array.isArray(pVal) && Array.isArray(oVal)) {
        prev[key] = pVal.concat(...oVal);
      }
      else if (isObject(pVal) && isObject(oVal)) {
        prev[key] = assign(pVal, oVal);
      }
      else {
        prev[key] = oVal;
      }
    });

    return prev;
  }, {});
}*/
//# sourceMappingURL=utils.js.map