simple-pure-utils/dist/types/logic.d.ts

Funciones puras para manipulación de objetos, arreglos, promesas y observables

import { Observable } from "rxjs";
/**Devuelve true si todos los elementos de un arreglo encajan con el predicado
 * @pred Devuelve la condición por cada elemento, si no se usa devuelve el elemento tal cual, es decir que los elementos deben de ser
 * truthy para pasar
*/
export declare function all<T>(arr: readonly T[], pred?: (x: T) => boolean): boolean;
/**Devuelve true si todos los elementos de un arreglo son iguales. Si el arreglo esta vacío devuelve true
 * @param comparer El comparador de igualdar, por default es @see referenceEquals
 */
export declare function allEqual<T>(arr: readonly T[], comparer?: (a: T, b: T) => boolean): boolean;
/**Devuelve true si por lo menos un elemento del arreglo encaja con el predicado, o si existe por lo menos un elemento en caso
 * de que el predicado este indefinido
 */
export declare function any<T>(arr: readonly T[], pred?: (x: T) => boolean): boolean;
/**Devuelve true si el valor existe en el arreglo */
export declare function contains<TA, TB>(arr: readonly TA[], value: TB, comparer?: (a: TA, b: TB) => boolean): boolean;
/**Devuelve true si todos los valores en @see values existen en el arreglo @see arr . Si @see values esta vacío devuelve true */
export declare function containsAll<T>(arr: readonly T[], values: readonly T[], comparer?: (a: T, b: T) => boolean): boolean;
/**Devuelve true si existe algun valor en @see values que exista en @see arr . Si @see values esta vacío devuelve false */
export declare function containsAny<T>(arr: readonly T[], values: readonly T[], comparer?: (a: T, b: T) => boolean): boolean;
/**
 * Alias para el operador ===
 * @param a
 * @param b
 */
export declare function referenceEquals<T>(a: T, b: T): boolean;
/**Compara dos arreglos valor por valor */
export declare function sequenceEquals<T>(a: readonly T[], b: readonly T[], comparer?: (a: T, b: T) => boolean): boolean;
/**Devuelve true si 2 arreglos contienen los mismos valores, sin considerar el orden o la cantidad de veces que el mismo valor esta repetido en el arreglo
 * @param comparer Función que se usa para comparar los elementos, si no se especifica, se usa el referenceEquals
 */
export declare function setEquals<T>(a: readonly T[], b: readonly T[], comparer?: (a: T, b: T) => boolean): boolean;
/**Compara dos objetos propiedad por propiedad */
export declare function shallowEquals<T>(a: T, b: T, comparer?: (a: T[keyof T], b: T[keyof T]) => boolean): boolean;
/**Resultado de un shallow diff */
export declare type ShallowDiffResult<T> = {
    [K in keyof T]?: true;
};
export declare type ObjSet<T> = {
    [K in keyof T]?: true;
};
/**
 * Compara 2 objetos propiedad por propiedad, devuelve un objeto con las propiedades que son diferentes asignadas a true
 * @param a Objeto a
 * @param b Objecto b
 * @param comparer Comparador de las propiedades. Se usa por default referenceEquals
 */
export declare function shallowDiff<T>(a: T, b: T, comparer?: (a: T[keyof T], b: T[keyof T]) => boolean): ObjSet<T>;
/**Convierte un ArrayLike o Iterable en un arreglo. Si el valor ya es un arreglo devuelve el valor */
export declare function toArray<T>(arr: ArrayLike<T> | Iterable<T>): T[];
/**Devuelve true si un objeeto se puede convertir a un arreglo utilizando la función toArray */
export declare function canBeArray(arr: any): arr is ArrayLike<any> | Iterable<any>;
/**Devuelve true si x es un array o un array like. Note que devuelve true para string. Normalmente es mejor usar la función @see isArray ya que esa si devuelve false para @see string*/
export declare function isArrayLike(x: any): x is ArrayLike<any>;
export declare function deepEquals<T>(a: T, b: T): boolean;
/**Convierte un arreglo a un objeto */
export declare function toMap<T, TValue>(arr: readonly T[], key: (value: T) => string, value: (value: T) => TValue): {
    [index: string]: TValue;
};
/**Aplana una colección de colecciones */
export declare function flatten<T>(arr: readonly T[][]): T[];
/**Devuelve el primer elemento de un arreglo o indefinido si no se encontro ninguno, opcionalmente
 * filtrado por un predicado
 */
export declare function first<T>(arr: readonly T[], pred?: (item: T) => boolean): T | undefined;
/**
 * Devuelve el unico elemento de un arreglo que cumpla con la condición, si no se encontró ninguo o mas de uno devuelve undefined
 */
export declare function single<T>(arr: readonly T[], pred?: (item: T) => boolean): T | undefined;
/**Devuelve el ultimo elemento de un arreglo */
export declare function last<T>(arr: readonly T[]): T | undefined;
export declare type Grouping<TKey, TItem> = {
    key: TKey;
    items: TItem[];
};
/**Agrupa un arreglo por una llave. Se preserva el orden original de los elementos del arreglo, segun los elementos agrupadores que aparezcan primero, tambien
 * el orden adentro del grupo es preservado
 * @param comparer Comparador de la llave por default es un shallowEquals
 */
export declare function groupBy<T, TKey>(arr: readonly T[], keySelector: (item: T) => TKey, comparer?: (a: TKey, b: TKey) => boolean): Grouping<TKey, T>[];
/**Agrupa un arreglo por una llave, siempre y cuando los elementos sean contiguos en el arreglo, es decir, si un grupo es interrumpido por un elemento con otra
 * clave se temrinara ese grupo y comenzará otro con la nueva clave, por lo que pueden existir multiples grupos no contiguos con la misma clave
 *
 * En caso de que @param arr este ordenado en funcion de @param keySelector, es equivalente pero mas eficiente que @see groupBy
 */
export declare function groupByAdjacent<T, TKey>(arr: readonly T[], keySelector: (item: T) => TKey, comparer?: (a: TKey, b: TKey) => boolean): Grouping<TKey, T>[];
/**Enumera todas las propiedades de un objeto en un arreglo
 * @param obj Objeto que se va a enumerar. Se devulve un arreglo de {value: T, key: string}
 */
export declare function enumObject<T>(obj: T): ({
    key: keyof T;
    value: T[keyof T];
})[];
/**
 * Enumera todas las propiedades de un objeto en un arreglo
 * @param obj Objeto que se va a enumerar
 * @param selector Función que obtiene cada elemento del arreglo
 */
export declare function enumObject<T, TR>(obj: T, selector: (key: keyof T, value: T[keyof T]) => TR): TR[];
/**
 * Convierte un arreglo en un objeto
 * @param array Arreglo donde se toma la propiedad "key" de cada elemento como key del objeto
 */
export declare function arrayToMap<TKey extends string | number | symbol, TValue>(array: {
    key: TKey;
    value: TValue;
}[]): {
    [K in TKey]: TValue;
};
/**
 * Convierte un arreglo a un objeto. Si el arreglo tiene varios elementos con la misma clave toma precedencia el ultimo
 * @param array Arreglo de valores
 * @param keySelector Función que obtiene la cadena que se tomada como el "key" de cada elemento
 */
export declare function arrayToMap<T, TKey extends string | number | symbol, TValue>(array: readonly T[], keySelector: (item: T, index: number) => TKey, valueSelector: (item: T, index: number) => TValue): {
    [K in TKey]: TValue;
};
/**Obtiene los valores numericos de un enum */
export declare function enumKeys<T>(e: T): T[keyof T][];
/**
 * Filtra las propiedades de un objeto
 * @param obj Objeto que se va a filtrar
 * @param pred Predicado que va a determinar que propiedades si se van a conservar
 */
export declare function filterObject<T extends {
    [key: string]: any;
}>(obj: T, pred: (value: T[keyof T], key: keyof T) => boolean): T;
/**
 * Quita un conjunto de propiedades de un objeto
 * @param obj El objeto original
 * @param keys Las propiedades que se desean quitar
 */
export declare function omit<T>(obj: T, keys: (keyof T)[]): T;
/**Quita las propiedades que esten indefinidas en un objeto */
export declare function omitUndefined<T>(obj: T): Partial<T>;
/**Devuelve un objeto son solo ciertas propiedades del objeto incluidas. Si se escoge una propiedad que no existe en el objeto esta no estará incluida en el objeto devuelto */
export declare function pick<T extends {}, Keys extends keyof T>(obj: T, ...props: Keys[]): {
    [K in Keys]: T[K];
};
/**Intercambia 2 elementos de un arreglo, si los indices dados estan afuera del arreglo, lanza una excepción */
export declare function swapItems<T>(array: readonly T[], a: number, b: number): T[];
/**Mueve un elemento del arreglo de un indice a otro, note que no es igual a swapItems ya que al mover un elemento se conserva el orden de todos los de más elemento, esto no ocurre con el swap que
 * simplemente intercambia de posición 2 elementos. Si los indices estan fuera de rango lanza uan excepción
*/
export declare function moveItem<T>(array: readonly T[], sourceIndex: number, destIndex: number): readonly T[];
/**Mueve un elemento hacia array o hacia abajo, si el elemento no se puede mover ya que esta en el borde del arreglo devuelve el arreglo tal cual */
export declare function upDownItem<T>(array: readonly T[], index: number, direction: "up" | "down"): readonly T[];
export declare type Promisify<T> = {
    [K in keyof T]: PromiseLike<T[K]>;
};
/**Aplica una función Promise.all a un objeto,  */
export declare function promiseAllObj<T>(obj: Promisify<T>): Promise<T>;
export declare type ObservableMap = {
    [K in string]: Observable<any>;
};
export declare type ObservableMapToSyncMap<T> = {
    [K in keyof T]: T[K] extends Observable<infer R> ? R : never;
};
export declare type PromiseMapToSyncMap<T> = {
    [K in keyof T]: T[K] extends PromiseLike<infer R> ? R : never;
};
/**Convierte un objeto de observables a un observable de objetos, el primer elemento del observable resultante se da cuando todos los observables del objeto lanzan el primer valor.
 * Es muy similar al @see combineLatest pero en lugar de funcionar con un arreglo funciona con un objeto
 */
export declare function objRxToRxObj<T extends ObservableMap>(obj: T): Observable<ObservableMapToSyncMap<T>>;
/**Convierte una promesa de un objeto a un objeto de promesas
 * @param include Nombres de las propiedades que se desean incluir en el objeto resultante
 */
export declare function awaitObj<T, TKeys extends keyof T>(obj: PromiseLike<T>, include: {
    [K in TKeys]: true;
}): Promisify<Pick<T, TKeys>>;
/**Devuelve todos los elementos de un arreglo que no estan repetidos, respetando el orden original en el que aparecen primero.
 * @param comparer Comparador que determina si 2 elementos son iguales. Se usa el operador ===
*/
export declare function unique<T>(arr: readonly T[], comparer?: (a: T, b: T) => boolean): T[];
/**Devuelve todos los elementos de todos los arreglos que no esten repetidos.
 * Conserva el orden pero no los elementos repetidos
 */
export declare function union<T>(...arr: readonly T[][]): T[];
/**
 * Devuelve todos los elementos en @param a que no estén en @param b, y
 * todos los elementos en @param b que no estén en @param a.
 * Es equivalente a la operación XOR / diferencia simétrica de conjuntos
 */
export declare function xor<T>(a: T[], b: T[]): T[];
/**
 * Devuelve todos los elementos en A que su llave no se encuentre en B las llaves de B y todos los elementos en B, en ese orden
 * esto equivale a unir los conjuntos A+B, pero dandole prioridad a los elementos en B si es que esa llave se encuentra en los dos conjuntos.
 * Esto se puede ver como una operacion de INSERT OR UPDATE en A
 * @param comparer Comparador de la llave. Es @see deepEquals por default
 */
export declare function unionKey<TA, TB, K>(a: readonly TA[], b: readonly TB[], getKey: (item: TA | TB) => K, comparer?: (a: K, b: K) => boolean): (TA | TB)[];
/**Devuelve todos los elementos en A que no esten en B. Es la operacion A-B de conjuntos. Conserva el orden y los elementos repetidos de A */
export declare function exclude<TA, TB>(a: readonly TA[], b: readonly TB[], comparer?: (a: TA, b: TB) => boolean): TA[];
/**Devuelve todos los elementos en "items" tal que su key no se encuentre una o mas veces en "keys". Conserva el orden original de "items".
 * @param keySelector Obtiene la clave de un elemento
 * @param comparer Comparedor de igualdad. Por default se usa el shallowEquals
 */
export declare function excludeKeys<T, TKey>(items: readonly T[], keys: readonly TKey[], keySelector: (item: T) => TKey, comparer?: (a: TKey, b: TKey) => boolean): T[];
/**Pega todos los elementos de los arreglos */
export declare function concat<T>(...arr: readonly T[][]): T[];
/**Filtra el arreglo sólo si condition == true, si es false devuelve el arreglo tal cual */
export declare function filterIf<T>(arr: readonly T[], predicate: (item: T) => boolean, condition: boolean): readonly T[];
/**Dado un arreglo de keys, para cada key mapea a el elemento que le corresponde.
 * Si existen varios elementos con la misma clave, cuando se encuentre esa clave se devolverá el primer elemento en el arreglo values con esa clave
 * @param keys Claves que se van a mapear
 * @param values Valores en los que se va a buscar para cada clave, el valor que tiene esa clave
 * @param keySelector Obtener la clave de un elemento
 * @param keyComparer Comparador que se usará para determinar si dos claves son iguales. Por default se usa el shallowEquals
 */
export declare function mapKeys<T, TKey>(keys: readonly TKey[], values: readonly T[], keySelector: (item: T) => TKey, keyComparer?: (a: TKey, b: TKey) => boolean): NonNullable<T>[];
/**Devuelve todos los elementos en "a" que se encuentren también en "b". Conserva el orden original de "a"
 * @param comparer Comparedor de igualdad. Por default se usa el referenceEquals
 */
export declare function intersect<T>(a: readonly T[], b: readonly T[], comparer?: (a: T, b: T) => boolean): T[];
/**Mapea cada una de las propiedades en A que encajen en B y viceversa */
export declare function mergeObj<TA, TB, TR>(a: TA, b: TB, merge: <TKey extends keyof (TA & TB)>(a: (TA[keyof TA] | undefined), b: (TB[keyof TB] | undefined), key: TKey) => TR): {
    [K in keyof (TA & TB)]: TR;
};
/**Devuelve true si SET contiene todos los elementos en SUBSET. Si los conjuntos son iguales devuelve true.
 * Si los dos arreglos estan vacios devuelve true
 */
export declare function isSubset<T>(set: readonly T[], subset: readonly T[], comparer?: (a: T, b: T) => boolean): boolean;
/**Devuelve todos los elementos en "items" tal que su key se encuentre una o mas veces en "keys". Conserva el orden original de "items".
 * @param keySelector Obtiene la clave de un elemento
 * @param comparer Comparador de igualdad. Por default se usa el shallowEquals
 */
export declare function intersectKeys<T, TKey>(items: readonly T[], keys: readonly TKey[], keySelector: (item: T) => TKey, comparer?: (a: TKey, b: TKey) => boolean): T[];
/**
 * Reordena items segun las claves en keys.
 * Si hay claves repetidas en el arreglo de keys, resulta en apariciones repetidas de ese elemento.
 * Si hay varios elementos con la misma clave, todos esos elementos aparecen en el orden original al aparecer su clave
 * Si no hay ningun elemento con cierta clave, esa clave se ignora
 * @param items Arreglo a reordenar
 * @param keys Arreglo de claves
 * @param keySelector Obtiene la clave de un elemento
 * @param comparer Comparador de igualdad. Por default se usa el shallowEquals
 */
export declare function reorder<T, TKey>(items: readonly T[], keys: readonly TKey[], keySelector: (item: T) => TKey, comparer?: (a: TKey, b: TKey) => boolean): T[];
/**Devuelve un rango de numeros */
export declare function range(start: number, count: number, step?: number): number[];
/**
 * Devuelve un nuevo arreglo con todo el arreglo original mas el elemento al final
 */
export declare function push<T>(arr: readonly T[], item: T): T[];
/**
 * Remplaza todos los valores del arreglo que cumplan con cierta condicion
 */
export declare function replace<T>(arr: readonly T[], condition: (item: T, index: number) => boolean, newValue: T): T[];
/**Elimina un elemento del arreglo */
export declare function remove<T>(arr: readonly T[], item: T): T[];
/**Elimina un elemento del arreglo dado su indice */
export declare function removeAt<T>(arr: readonly T[], index: number): T[];
/**
 * Combina varias funciones comparadores que pueden ser usadas para alimentar a la función sort. Se le da prioridad a los primeros comparadores,
 * si un comparador devuelve 0, entonces se evalue el segundo
 * @param comparers
 */
export declare function combineComparers<T>(...comparers: ((a: T, b: T) => number)[]): (a: T, b: T) => number;
/**Comparador de ordenamiento por default. Si a es mayor que b devuelve 1, si es menor -1  */
export declare function defaultComparer<T>(a: T, b: T): number;
export declare type ComparerFunction<T> = (a: T, b: T) => number;
/**Ordena un arreglo de forma estable, a diferencia de con array.sort el arreglo original no es modificado
 * @param comparers Comparadores de ordenamiento, se le da precedencia al primero. Si no se especifica ninguno se usará el comparador por default
 */
export declare function sort<T>(arr: readonly T[], ...comparers: (ComparerFunction<T>)[]): T[];
/**
 * Ordena un arreglo de forma estable segun ciertas claves seleccionadas usando el comparador por default
 */
export declare function orderBy<T>(arr: readonly T[], ...keySelectors: ((x: T) => any)[]): T[];
/**Ordena un arreglo de forma estable y descendiente segun ciertas claves seleccionadas usando el comparador por default */
export declare function orderByDesc<T>(arr: readonly T[], ...keySelectors: ((x: T) => any)[]): T[];
/**Obtiene el máximo de un arreglo dado un selector de llave */
export declare function max<T>(arr: readonly T[], ...keySelectors: ((x: T) => any)[]): T | undefined;
/**Obtiene el mínimo de un arreglo dado un selector de llave */
export declare function min<T>(arr: readonly T[], ...keySelectors: ((x: T) => any)[]): T | undefined;
/**Convierte un observable de T, de Promise<T> o de Observable<T> a un observable de <T>, efectivamente aplanando un observable anidado en uno desanidado */
export declare function rxFlatten<T>(observable: Observable<T | PromiseLike<T> | Observable<T>>): Observable<T>;
/**Convierte un valor o una promesa a una promesa. No devuelve Promise ya que si el valor es síncrono devuelve un PromiseLike que se resuelve inmediatamente
 * (el tipo Promise no se resuelve de inmediato)
 */
export declare function valToPromise<T>(value: T | PromiseLike<T>): PromiseLike<T>;
/**Convierte una promesa a observable, si la promesa se resuelve las siguientes subscripciones obtienen el valor de la promesa de forma síncorna */
export declare function promiseToObservable<T>(prom: PromiseLike<T>): Observable<T>;
/**Convierte una función que devuelve una promesa a un observable,
 * la función es llamada sólamente una vez en la primera subscripción del observable, subsecuentes subscripciones al observable no resultan en nuevas
 * llamadas al thunk.
 *
 * Una vez que el thunk se reseulve su valor se almacena y subscripciones posteriores devuelven inmedatamente el valor y se completan.
 *
 * @param thunk Función que se va a llamar sólo una vez, en la primera subscripción.
 */
export declare function asyncThunkToObservable<T>(thunk: () => PromiseLike<T>): Observable<T>;
/**Convierte un valor o una promesa a un observable, si el valor ya es un observable lo devuelve tal cual */
export declare function toObservable<T>(value: T | PromiseLike<T> | Observable<T>): Observable<T>;
/**Toma los primeros N elementos del arreglo */
export declare function take<T>(arr: readonly T[], count: number): T[];
/**Se salta los primeros N elementos del arreglo */
export declare function skip<T>(arr: readonly T[], count: number): T[];
/**Obtiene le primer elemento mapeado de un arreglo o undefined */
export declare function firstMap<T, R>(arr: readonly T[], predicate: (x: T, index: number) => boolean, map: (x: T, i: number) => R): R | undefined;
/**Devuelve true si existiran duplicados en caso de editar un elemento de un arreglo
 * @param arr Arreglo
 * @param oldValueRef Valor anterior del arreglo
 * @param newValue Nuevo valor del arreglo
 */
export declare function duplicatesOnEdit<T, TKey>(arr: readonly T[], oldValue: T, newValue: T, keySelector: (x: T) => TKey): boolean;
/**
 * Devuelve true si existirán duplicados en caso de agregar un elemento a un arreglo que es equivalente a saber
 * si ese elemento esta contenido en el arreglo
 * @param arr
 * @param newValue
 * @param comparer  Se usa el shallow equals por default
 */
export declare function duplicatesOnAdd<T, TKey>(arr: readonly T[], newValue: T, keySelector: (x: T) => TKey): boolean;
/**Devuelve true si x es un observable */
export declare function isObservable(x: any): x is Observable<any>;
/**Devuelve true si x es un array */
export declare function isArray(x: any): x is any[];
/**Mapea el valor actual y el anterior de un observable */
export declare function mapPreviousRx<T>(obs: Observable<T>, startWith: T): Observable<{
    prev: T;
    curr: T;
}>;
/**Mapea cada elemento de un arreglo tomando en cuenta el elemento anterior */
export declare function mapPrevious<T, TR>(items: readonly T[], map: (prev: T, curr: T) => TR, initial: T): TR[];
/**Calcula un agregado corrido para cada elemento de un arreglo */
export declare function runningTotal<TIn, TState, TOut>(items: readonly TIn[], seed: TState, reduceState: (state: TState, item: TIn) => TState, map: (state: TState, item: TIn) => TOut): TOut[];
/**Calcula el agregado corrido para cada elemento, recorriendo el arreglo al revez */
export declare function runningTotalRight<TIn, TState, TOut>(items: readonly TIn[], seed: TState, reduceState: (state: TState, item: TIn) => TState, map: (state: TState, item: TIn) => TOut): TOut[];
/**Mapea y aplana una colección. Es equivalente a  flatten(items.map(map)) */
export declare function mapMany<T, TR>(items: readonly T[], map: (x: T) => TR[]): TR[];
/**Divide @param arr en bloques de longitud máxima @param count,
 * si @param arr está vacío, devuelve un arreglo vacío
 */
export declare function groupByCount<T>(arr: T[], count: number): T[][];
/**Convierte un objeto de arreglos a un arreglo de objetos, si el objeto de arreglos esta vacio, devuelve un arreglo vacio
 * @param length
 *  undefined = Todos los arreglos deben de tener la misma longitud
 *  min = La longitud de retorno será la minima
 *  max = La longitud de retorno será la máxima, pueden haber elementos indefinidos
*/
export declare function zip<TData>(data: {
    [K in keyof TData]: TData[K][];
}, length?: "min"): TData[];
export declare function zip<TData>(data: {
    [K in keyof TData]: TData[K][];
}, length: "max"): Partial<TData>[];
/**Formatea una moneda con 2 decimales y separador de miles
 */
export declare function formatCurrency(number: number | null | undefined | string): string;
/**
 * Formatea un número
 * @param number El numero
 * @param integer Cantidad de zeros a la izquierda en la parte entera
 * @param decimals Cantidad de zeros a la derecha en la parte desimal
 * @param thousep Usar separador de miles. Por default es false
 * @param prefix Prefijo del numero, ejemplo $ o %. Por default es ""
 * @param sign True para mostrar signo + si el valor > 0, si no, sólo se muestra si valor < 0
 */
export declare function formatNumber(number: number | null | undefined | string, integer?: number, decimals?: number, thousep?: boolean, prefix?: string, sign?: boolean): string;
/**Devuelve true si la cadena es null, undefined o string */
export declare function nullOrEmpty(x: string): x is ("");
/**Devuelve true si la cadena es null, undefined o string */
export declare function nullOrEmpty(x: null | string): x is (null | "");
/**Devuelve true si la cadena es null, undefined o string */
export declare function nullOrEmpty(x: undefined | string): x is (undefined | "");
/**Devuelve true si la cadena es null, undefined o string */
export declare function nullOrEmpty(x: null | undefined | string): x is (null | undefined | "");
/**Formatea una fecha
 * @param fullDateTime true o false para indicar si mostrar las horas o no. Por default es undefined e implicar que se mostraran las horas si el valor tiene componente de horas, si no, se mostrará sólo la fecha
 */
export declare function formatDate(x: Date | null | undefined | string, fullDateTime?: boolean): string;
/**Convierte una representación de una fecha a una fecha */
export declare function toDate(value: Date | string | number): Date;
/**Convierte una representación de una fecha a una fecha */
export declare function toDate<TNull extends null | undefined>(value: Date | string | TNull | number): Date | TNull;
/**Convierte una fecha al formato ISO 8601 respetando la zona horaria */
export declare function toIsoDate(x: Date): string;
/**Formatea una fecha de tal manera que sea compatible con el excel */
export declare function formatDateExcel(x: Date): string;
/**Devuelve una promesa que se resuelve en cierto tiempo. Note que si ms == 0 la promesa devuelta no se resuelve síncronamente, ya que un setTimeout(..., 0) no es síncrono*/
export declare function delay(ms: number): PromiseLike<void>;
/**Una funcion que siempre lanza una excepción al ser llamada. Sirve para implementar cases exhaustivos, tal como esta descrito en https://stackoverflow.com/questions/39419170/how-do-i-check-that-a-switch-block-is-exhaustive-in-typescript*/
export declare function assertUnreachable(x: never): never;
/**Devuelve el indice de la primera aparición de un elemento que cumpla con @see pred */
export declare function indexOf<T>(arr: ArrayLike<T>, pred: (x: T) => boolean, startIndex?: number): number | null;
/**Devuelve los indices de todas las apariciones de los items que cumplan con @see pred */
export declare function indicesOf<T>(arr: ArrayLike<T>, pred: (x: T) => boolean, startIndex?: number): number[];
/**Realiza una busqueda binaria en un arreglo, devuelve el indice del elemento mas cercano y si fue encontrado o no el elemento.
 * En caso de que no encaje devuelve el indice del ultimo elemento que es menor que el valor de busqueda. Si ningun elemento del arreglo es menor al valor de busqueda devuelve -1.
 */
export declare function binarySearch<T, TKey>(arr: readonly T[], keySelector: (x: T) => TKey, value: TKey, comparer?: (a: TKey, b: TKey) => number): {
    index: number;
    match: boolean;
};
/**
 * Para todos los pares de elemento en left y right que cumplen con el where, devuelve ese par de elementos
 * Se respeta el orden del arreglo @see left
 * Este algoritmo corre con complejidad O^2 o NM donde N es la cantidad de elementos en left y M la cantidad de elementos en right
 * @param left Arreglo izquierdo
 * @param right Arreglo derecho
 * @param where Condicion para filtrar el producto cartesiano
 */
export declare function innerJoin<TA, TB>(left: readonly TA[], right: readonly TB[], where: (left: TA, right: TB) => boolean): {
    left: TA;
    right: TB;
}[];
/**
 * Para todos los elementos en left y right que cumplen con el where, devuelve ese par de elementos. Si para
 * cierto elemento en left ningun par de elementos (left, right) cumple con la condicion, devuelve un par solo con el valor (left) asignado y el
 * (right) en undefined. Esto hace que todos los elementos en left sean incluidos en el resultado final incondicionalmente por lo menos una vez * Este algoritmo corre con complejidad O^2 o NM donde N es la cantidad de elementos en left y M la cantidad de elementos en right
 * @param left Arreglo izquierdo
 * @param right Arreglo derecho
 * @param where Condicion para filtrar el producto cartesiano
 */
export declare function leftJoin<TA, TB>(left: readonly TA[], right: readonly TB[], where: (left: TA, right: TB) => boolean): {
    left: TA;
    right?: TB;
}[];
/**Combina dos rutas. Combina correctamente las rutas con ./ y ../
 * @param ruta base
 * @param path Ruta actual
 * @param pathChar Caracter que divide a la ruta
 * @param prefix True para iniciar la ruta con el caracter de ruta, false para no iniciar, indefinido para dejarlo tal cual. Por default is true
 * @param postfix True para terminar la ruta con el caracter de ruta, false para quitarlo, indefinido para dejarlo tal cual
 */
export declare function combinePath(basePath: string, path: string, pathChar?: string, prefix?: boolean | undefined, postfix?: boolean | undefined): string;
/**Suma un arreglo de numeros. Si el arreglo esta vacío devuelve 0.
 * Los valores nulos o indefinidos son ignorados en la suma
 */
export declare function sum(arr: (number | null | undefined)[]): number;
/**Convierte un observable a una promesa que se resuelve en el siguiente onNext del observable, esto es diferente a la función
 * @see Observable.toPromise() que se resueve hasta que el observable es completado.
 *
 * Si el observable devuelve un elemento de inmediato, la promesa devuelta se resuelve síncronamiente
*/
export declare function nextToPromise<T>(obs: Observable<T>): PromiseLike<T>;
/**Tipo de un extremo del rango */
export declare type RangeEndType = "in" | "ex";
/**Un extremo de un rango de numeros */
export interface RangeType {
    value: number | string | Date;
    type: RangeEndType;
}
/**Un rango de numeros */
export interface RangeOptional {
    /**Minimo del rango */
    min?: RangeType;
    /**Máximo del rango */
    max?: RangeType;
}
export declare type RangeCheckResult = "min" | "max";
/**Determina si un numero esta afuera del rango, y devuelve de que parte del rango esta afuera */
export declare function outOfRange(value: number, range: RangeOptional): RangeCheckResult | null;
/**Barajea un arreglo */
export declare function shuffle<T>(arr: readonly T[]): T[];
/**
 * Aplica una función a cada propiedad de un objeto, conservando los keys
 * @param obj Objeto a mapear
 * @param map Función que toma el valor y el "key" y devuelve el nuevo valor
 */
export declare function mapObject<T, TOut>(obj: T, map: <K extends keyof T>(value: T[K], key: K) => TOut): ({
    [K in keyof T]: TOut;
});
/**Ejecuta un OR sobre un conjunto de valores ya sea síncronos o asíncronos, si los primeros valores son síncronos devuelve inmediatamente ese resultado sin esperar a los otros observables */
export declare function orRx<T>(...arg: (T | Observable<T>)[]): T | Observable<T>;
/**Recorre una estructura de arbol y la devuelve en forma de arreglo */
export declare function treeTraversal<T>(tree: readonly T[], getNodes: (x: T) => T[]): T[];
/**Convierte una función para obtener un valor y otra que notifica el cambio del valor en un observable
 * @param getValue Función que obtiene el valor actual
 * @param listen Una función que se suscribe a los cambios del valor, toma como parámetro una función que se va a llamar cada vez que el valor que cambie y devuelve
 * una función que al ser llamada se desuscribe de la escucha de los cambios del valor
 */
export declare function getListenToRx<T>(getValue: () => T, listen: (onChange: () => void) => (() => void)): Observable<T>;
/**Un store de redux */
export interface ReduxStore<TState> {
    subscribe: (onChange: () => void) => (() => void);
    getState: () => TState;
}
/**Convierte un store de redux en un observable, el observable emite el valor actual en la subscripción y los siguientes valores son emitidos
 * cuando el store indica que ha cambiado su valor
 */
export declare function reduxStoreToRx<TState>(store: ReduxStore<TState>): Observable<TState>;
/** Example
import {from} from 'rxjs/observable/from';
from([1, 2, 3])
    .pipe(doOnSubscribe(() => console.log('subscribed to stream')))
    .subscribe(x => console.log(x), null, () => console.log('completed'));
*/
export declare function doOnSubscribe<T>(onSubscribe: () => void): (source: Observable<T>) => Observable<T>;
/**Convierte una observable a una promesa, donde la promesa tiene el ultimo valor devuelto por el observable y se resuelve una vez que el observable es completado.
 * La diferencia entre este y el rxjs.toPromise es que si el observable se resuelve de manera sincrona la promesa devuelta también se resuelve de forma síncrona,
 * ya que el resultado de rxjs.toPromise es siempre una promesa asíncrona
 */
export declare function obsToPromise<T>(obs: Observable<T>): PromiseLike<T>;
/**Quita todas las apariciones de @param patt a la izquierda de string */
export declare function trimLeft(str: string, patt: string): string;
/**Quita todas las apariciones de @param patt a la derecha de string */
export declare function trimRight(str: string, patt: string): string;
export declare function trim(str: string, patt: string): string;
/**Remplaza todas las apariciones de @see searchValue */
export declare function replaceAll(str: string, searchValue: string | RegExp, replaceValue: string): string;
/**Convierte a numero una cadena que puede tener prefijos (ej. $) y separador de miles */
export declare function parseFormattedNumber(val: string): number;
/**Obtiene la precision de decimales de un numero en forma de cadena, soporta la notación exponencial */
export declare function getDecimalCount(str: string): number;
/**True si un numero es igual a su representación de cadena formateada, la comparación de decimales se hace
 * basandose en la cantidad de decimales de la cadena
 */
export declare function numEqStr(num: number, str: string): boolean;
/**Interpolación lineal entre 2 numeros */
export declare function lerp(a: number, b: number, x: number): number;
/**Pega todos los classNames, separandolos con espacios, ignorando los falsy */
export declare function mixClasses(...classNames: (string | false | null | undefined)[]): string;
/**Converts a hex string to ascii, if the string starts with 0x, this is ignored */
export declare function hexToAscii(hex: string): string;
/** Returns hex representation of "ascii", does not includes "0x" */
export declare function asciiToHex(ascii: string): string;
/** Left padds "text" with repeated "char" until result is of lenght "len", if text length > len, text is returned*/
export declare function padLeft(text: string, len: number, char?: string): string;
/** Right padds "text" with repeated "char" until result is of lenght "len", if text length > len, text is returned*/
export declare function padRight(text: string, len: number, char?: string): string;