@thisisagile/easy/dist/types/List.d.ts

Straightforward library for building domain-driven microservice architectures

import { ArrayLike } from './Array';
import { Constructor } from './Constructor';
import type { Json } from './Json';
import { Get, GetProperty } from './Get';
import type { Id } from './Id';
import { Optional } from './Types';
import { AnyKey } from './AnyKey';
import { Indexed } from './Indexed';
type Pred<T> = (value: T, index: number, obj: T[]) => unknown;
export declare class List<T = unknown> extends Array<T> {
    get ids(): List<Id>;
    get indexed(): List<Indexed<T>>;
    isSubSetOf(...items: ArrayLike<T>): boolean;
    isSuperSetOf(...items: ArrayLike<T>): boolean;
    isIntersectingWith(...items: ArrayLike<T>): boolean;
    isDisjointWith(...items: ArrayLike<T>): boolean;
    areEqual(...items: ArrayLike<T>): boolean;
    asc(p: GetProperty<T, any>): List<T>;
    desc(p: GetProperty<T, any>): List<T>;
    first(p?: Pred<T>, params?: unknown): T;
    firstValue<V>(f: (t: T) => V, alt?: Get<V, T>): Optional<V>;
    isFirst(value: T): boolean;
    next(p?: Pred<T>, params?: unknown): T;
    prev(p?: Pred<T>, params?: unknown): T;
    last(p?: Pred<T>, params?: unknown): T;
    isLast(value: T): boolean;
    overlaps(...items: ArrayLike<T>): boolean;
    diff(others: ArrayLike<T>): List<T>;
    diffByKey<U = T>(others: ArrayLike<U>, key: keyof T & keyof U): List<T>;
    symmetricDiff(others: ArrayLike<T>): List<T>;
    symmetricDiffByKey(others: ArrayLike<T>, key: keyof T): List<T>;
    intersect(others: ArrayLike<T>): List<T>;
    intersectByKey<U>(others: ArrayLike<U>, key: keyof T & keyof U): List<T>;
    intersectBy<U>(others: ArrayLike<U>, f: (value: T, value2: U) => boolean): List<T>;
    accumulate(...keys: (keyof T)[]): List<T>;
    toJSON(): Json[];
    map<U>(f: (value: T, index: number, array: T[]) => U, params?: unknown): List<U>;
    flatMap<U, This = unknown>(f: (this: This, value: T, index: number, array: T[]) => ReadonlyArray<U> | U, params?: This): List<U>;
    mapDefined<U>(f: (value: T, index: number, array: T[]) => U, params?: unknown): List<NonNullable<U>>;
    mapAsync(f: (i: T) => Promise<T>): Promise<List<T>>;
    mapSerial<U>(f: (i: T) => Promise<U>): Promise<List<U>>;
    distinct(): List<T>;
    distinctByKey(key: keyof T): List<T>;
    distinctByValue(): List<T>;
    filter(p: Pred<T>, params?: unknown): List<T>;
    sum(p: (t: T) => number): number;
    max(p: (value: T) => any): T;
    max(key: keyof T): T;
    min(key: keyof T): T;
    min(p: (value: T) => any): T;
    byId(id: Id): T;
    byKey(key: keyof T, value: unknown): T;
    add(...items: ArrayLike<T>): this;
    concat(...items: ConcatArray<T>[]): List<T>;
    concat(...items: (T | ConcatArray<T>)[]): List<T>;
    reverse(): List<T>;
    splice(start: number, deleteCount?: number): List<T>;
    splice(start: number, deleteCount: number, ...items: T[]): List<T>;
    remove(item: T): List<T>;
    move(sourceId: Id, destinationId: Id): List<T>;
    moveOn(key: keyof T, sourceId: Id, destinationId: Id): List<T>;
    replace(key: keyof T, item: T): List<T>;
    switch(item: T): List<T>;
    switchOn<U = T>(item: U, on: AnyKey<U>): List<T>;
    switchOn<T>(item: T, on: Pred<T>): List<T>;
    defined(): List<NonNullable<T>>;
    toObject(key: keyof T, options?: {
        deleteKey?: boolean;
    }): Record<string | number | symbol, T>;
    toObjectList(key: keyof T): Record<string | number | symbol, List<T>>;
    orElse(...alt: ArrayLike<T>): Optional<List<T>>;
    weave(insertFrom: T[], interval: number): this;
    slice(start?: number, end?: number): List<T>;
    none(p: (t: T) => boolean): boolean;
    chunk(chunkSize: number): List<List<T>>;
    update<U = T>(p: Pred<T>, val: T | ((v: U) => T)): List<T>;
    updateFirst<U = T>(p: Pred<T>, val: T | ((v: U) => T)): List<T>;
    updateFirstById<U = T>(id: Id, val: T | ((v: U) => T)): List<T>;
    updateById<U = T>(id: Id, val: T | ((v: U) => T)): List<T>;
    groupBy(by: Pred<T>): List<List<T>>;
}
export declare const toList: <T = unknown>(...items: ArrayLike<T>) => List<T>;
export declare const isList: <T>(l?: unknown) => l is List<T>;
export declare const asList: <T>(c: Constructor<T>, items?: unknown) => List<T>;
export declare const maxValue: <T>(l: List<T>, key: keyof T) => T[keyof T] | undefined;
export declare const minValue: <T>(l: List<T>, key: keyof T) => T[keyof T] | undefined;
export {};