@arrows/array/index.d.ts

Functional tools for JS arrays

import aperture_ from "./aperture_";
import append_ from "./append_";
import butLast_ from "./butLast_";
import chunk_ from "./chunk_";
import clear_ from "./clear_";
import concat from "./concat";
import entries from "./entries";
import every from "./every";
import fill from "./fill";
import filter from "./filter";
import filterNot_ from "./filterNot_";
import find from "./find";
import findIndex from "./findIndex";
import first_ from "./first_";
import flat from "./flat";
import flatMap from "./flatMap";
import forEach from "./forEach";
import get_ from "./get_";
import groupBy_ from "./groupBy_";
import has_ from "./has_";
import includes from "./includes";
import indexOf from "./indexOf";
import insert_ from "./insert_";
import join from "./join";
import keys from "./keys";
import last_ from "./last_";
import lastIndexOf from "./lastIndexOf";
import map from "./map";
import prepend_ from "./prepend_";
import range_ from "./range_";
import reduce from "./reduce";
import reduceRight from "./reduceRight";
import remove_ from "./remove_";
import rest_ from "./rest_";
import reverse from "./reverse";
import set_ from "./set_";
import setSize_ from "./setSize_";
import size_ from "./size_";
import slice from "./slice";
import some from "./some";
import sort from "./sort";
import sortBy_ from "./sortBy_";
import toLocaleString from "./toLocaleString";
import toString from "./toString";
import update_ from "./update_";
import values from "./values";
import zip_ from "./zip_";
import zipWith_ from "./zipWith_";
export { aperture_, append_, butLast_, chunk_, clear_, concat, entries, every, fill, filter, filterNot_, find, findIndex, first_, flat, flatMap, forEach, get_, groupBy_, has_, includes, indexOf, insert_, join, keys, last_, lastIndexOf, map, prepend_, range_, reduce, reduceRight, remove_, rest_, reverse, set_, setSize_, size_, slice, some, sort, sortBy_, toLocaleString, toString, update_, values, zip_, zipWith_, };
declare const _default: {
    aperture_: (<T>(chunkSize: number, arr: T[]) => T[][]) & (<T_1>(chunkSize: number) => (arr: T_1[]) => T_1[][]);
    append_: (<T_2>(value: T_2, arr: T_2[]) => T_2[]) & (<T_3>(value: T_3) => (arr: T_3[]) => T_3[]);
    butLast_: <T_4>(arr: T_4[]) => T_4[];
    chunk_: (<T_5>(chunkSize: number, arr: T_5[]) => T_5[][]) & (<T_6>(chunkSize: number) => (arr: T_6[]) => T_6[][]);
    clear_: <T_7>(arr: T_7[]) => [];
    concat: (<T_8>(value: T_8 | T_8[], arr: T_8[]) => T_8[]) & (<T_9>(value: T_9 | T_9[]) => (arr: T_9[]) => T_9[]);
    entries: <T_10>(arr: T_10[]) => IterableIterator<[number, T_10]>;
    every: (<T_11>(testFn: (element: T_11, index: number, arr: T_11[]) => boolean, arr: T_11[]) => boolean) & (<T_12>(testFn: (element: T_12, index: number, arr: T_12[]) => boolean) => (arr: T_12[]) => boolean);
    fill: (<T_13, V>(startIndex: number | undefined, endIndex: number | undefined, value: V, arr: (T_13 | V)[]) => (T_13 | V)[]) & {
        <T_14, V_1>(startIndex: number | undefined): {
            (endIndex: number | undefined): {
                (value: V_1): (arr: T_14[]) => (T_14 | V_1)[];
                (value: V_1, arr: (T_14 | V_1)[]): (T_14 | V_1)[];
            };
            (endIndex: number | undefined, value: V_1): (arr: T_14[]) => (T_14 | V_1)[];
            (endIndex: number | undefined, value: V_1, arr: (T_14 | V_1)[]): (T_14 | V_1)[];
        };
        <T_15, V_2>(startIndex: number | undefined, endIndex: number | undefined): {
            (value: V_2): (arr: T_15[]) => (T_15 | V_2)[];
            (value: V_2, arr: (T_15 | V_2)[]): (T_15 | V_2)[];
        };
        <T_16, V_3>(startIndex: number | undefined, endIndex: number | undefined, value: V_3): (arr: T_16[]) => (T_16 | V_3)[];
    } & {
        all: {
            <T_17, V_4>(value: V_4, arr: T_17[]): V_4[];
            <T_18, V_5>(value: V_5): (arr: T_18[]) => V_5[];
        };
        end: {
            <T_19, V_6>(endIndex: number, value: V_6, arr: (T_19 | V_6)[]): (T_19 | V_6)[];
            <T_20, V_7>(endIndex: number, value: V_7): (arr: T_20[]) => (T_20 | V_7)[];
            <T_21, V_8>(endIndex: number): {
                (value: V_8): (arr: T_21[]) => (T_21 | V_8)[];
                (value: V_8, arr: (T_21 | V_8)[]): (T_21 | V_8)[];
            };
        };
        start: (<T_22, V_9>(startIndex: number, value: V_9, arr: (T_22 | V_9)[]) => (T_22 | V_9)[]) & {
            <T_23, V_10>(startIndex: number, value: V_10): (arr: T_23[]) => (T_23 | V_10)[];
            <T_24, V_11>(startIndex: number): {
                (value: V_11): (arr: T_24[]) => (T_24 | V_11)[];
                (value: V_11, arr: (T_24 | V_11)[]): (T_24 | V_11)[];
            };
        };
    };
    filter: (<T_25>(fn: (element: T_25, index: number, arr: T_25[]) => boolean, arr: T_25[]) => T_25[]) & (<T_26>(fn: (element: T_26, index: number, arr: T_26[]) => boolean) => (arr: T_26[]) => T_26[]);
    filterNot_: (<T_27>(fn: (element: T_27, index: number, arr: T_27[]) => boolean, arr: T_27[]) => T_27[]) & (<T_28>(fn: (element: T_28, index: number, arr: T_28[]) => boolean) => (arr: T_28[]) => T_28[]);
    find: (<T_29>(testFn: (element: T_29, index: number, arr: T_29[]) => boolean, arr: T_29[]) => T_29 | undefined) & (<T_30>(testFn: (element: T_30, index: number, arr: T_30[]) => boolean) => (arr: T_30[]) => T_30 | undefined);
    findIndex: (<T_31>(testFn: (element: T_31, index: number, arr: T_31[]) => boolean, arr: T_31[]) => number) & (<T_32>(testFn: (element: T_32, index: number, arr: T_32[]) => boolean) => (arr: T_32[]) => number);
    first_: <T_33>(arr: T_33[]) => T_33;
    flat: (<T_34>(depth: number, arr: T_34[]) => unknown[]) & (<T_35>(depth: number) => (arr: T_35[]) => unknown[]) & {
        one: <T_36>(arr: T_36[][]) => T_36[];
    };
    flatMap: (<T_37>(mappingFn: (currentValue: T_37, index?: number | undefined, array?: T_37[] | undefined) => unknown, arr: T_37[]) => unknown[]) & (<T_38>(mappingFn: (currentValue: T_38, index?: number | undefined, array?: T_38[] | undefined) => unknown) => (arr: T_38[]) => unknown[]);
    forEach: (<T_39>(sideEffectFn: (currentValue?: T_39 | undefined, index?: number | undefined, array?: T_39[] | undefined) => unknown, arr: T_39[]) => void) & (<T_40>(sideEffectFn: (currentValue?: T_40 | undefined, index?: number | undefined, array?: T_40[] | undefined) => unknown) => (arr: T_40[]) => void);
    get_: (<T_41>(index: number, arr: T_41[]) => T_41 | undefined) & (<T_42>(index: number) => (arr: T_42[]) => T_42 | undefined);
    groupBy_: (<T_43 extends object>(groupingFn: (x: T_43) => string, arr: T_43[]) => {
        [key: string]: T_43[];
    }) & (<T_44 extends object>(groupingFn: (x: T_44) => string) => (arr: T_44[]) => {
        [key: string]: T_44[];
    });
    has_: ((index: number, arr: unknown[]) => boolean) & ((index: number) => (arr: unknown[]) => boolean);
    includes: (<T_45>(element: T_45, arr: T_45[]) => boolean) & (<T_46>(element: T_46) => (arr: T_46[]) => boolean);
    indexOf: (<T_47>(element: T_47, fromIndex: number, arr: T_47[]) => number) & {
        <T_48>(element: T_48): {
            (fromIndex: number): (arr: T_48[]) => number;
            (fromIndex: number, arr: T_48[]): number;
        };
        <T_49>(element: T_49, fromIndex: number): (arr: T_49[]) => number;
    } & {
        all: (<T_50>(element: T_50, arr: T_50[]) => number) & (<T_51>(element: T_51) => (arr: T_51[]) => number);
    };
    insert_: (<T_52>(value: T_52, index: number, arr: T_52[]) => T_52[]) & {
        <T_53>(value: T_53): {
            (index: number): (arr: T_53[]) => T_53[];
            (index: number, arr: T_53[]): T_53[];
        };
        <T_54>(value: T_54, index: number): (arr: T_54[]) => T_54[];
    };
    join: (...x: any[]) => any;
    keys: <T_55>(arr: T_55[]) => IterableIterator<number>;
    last_: <T_56>(arr: T_56[]) => T_56;
    lastIndexOf: (<T_57>(element: T_57, fromIndex: number, arr: T_57[]) => number) & {
        <T_58>(element: T_58): {
            (fromIndex: number): (arr: T_58[]) => number;
            (fromIndex: number, arr: T_58[]): number;
        };
        <T_59>(element: T_59, fromIndex: number): (arr: T_59[]) => number;
    } & {
        all: (<T_60>(element: T_60, arr: T_60[]) => number) & (<T_61>(element: T_61) => (arr: T_61[]) => number);
    };
    map: (<T_62>(mappingFn: (currentValue?: T_62 | undefined, index?: number | undefined, array?: T_62[] | undefined) => unknown, arr: T_62[]) => unknown[]) & (<T_63>(mappingFn: (currentValue?: T_63 | undefined, index?: number | undefined, array?: T_63[] | undefined) => unknown) => (arr: T_63[]) => unknown[]);
    prepend_: (<T_64>(value: T_64, arr: T_64[]) => T_64[]) & (<T_65>(value: T_65) => (arr: T_65[]) => T_65[]);
    range_: (from: number, to: number, step?: number | undefined) => number[];
    reduce: (<T_66, X>(reducingFn: (accumulator: X, currentValue: T_66, index?: number | undefined, arr?: T_66[] | undefined) => X, initialValue: X, arr: T_66[]) => X) & {
        <T_67, X_1>(reducingFn: (accumulator: X_1, currentValue: T_67, index?: number | undefined, arr?: T_67[] | undefined) => X_1): {
            (initialValue: X_1): (arr: T_67[]) => X_1;
            (initialValue: X_1, arr: T_67[]): X_1;
        };
        <T_68, X_2>(reducingFn: (accumulator: X_2, currentValue: T_68, index?: number | undefined, arr?: T_68[] | undefined) => X_2, initialValue: X_2): (arr: T_68[]) => X_2;
    } & {
        first: (<T_69>(reducingFn: (accumulator: T_69, currentValue: T_69, index?: number | undefined, arr?: T_69[] | undefined) => T_69, arr: T_69[]) => T_69) & (<T_70>(reducingFn: (accumulator: T_70, currentValue: T_70, index?: number | undefined, arr?: T_70[] | undefined) => T_70) => (arr: T_70[]) => T_70);
    };
    reduceRight: (<T_71, X_3>(reducingFn: (accumulator: X_3, currentValue: T_71, index?: number | undefined, arr?: T_71[] | undefined) => X_3, initialValue: X_3, arr: T_71[]) => X_3) & {
        <T_72, X_4>(reducingFn: (accumulator: X_4, currentValue: T_72, index?: number | undefined, arr?: T_72[] | undefined) => X_4): {
            (initialValue: X_4): (arr: T_72[]) => X_4;
            (initialValue: X_4, arr: T_72[]): X_4;
        };
        <T_73, X_5>(reducingFn: (accumulator: X_5, currentValue: T_73, index?: number | undefined, arr?: T_73[] | undefined) => X_5, initialValue: X_5): (arr: T_73[]) => X_5;
    } & {
        first: (<T_74>(reducingFn: (accumulator: T_74, currentValue: T_74, index?: number | undefined, arr?: T_74[] | undefined) => T_74, arr: T_74[]) => T_74) & (<T_75>(reducingFn: (accumulator: T_75, currentValue: T_75, index?: number | undefined, arr?: T_75[] | undefined) => T_75) => (arr: T_75[]) => T_75);
    };
    remove_: (<T_76>(index: number, arr: T_76[]) => T_76[]) & (<T_77>(index: number) => (arr: T_77[]) => T_77[]);
    rest_: <T_78>(arr: T_78[]) => T_78[];
    reverse: <T_79>(arr: T_79[]) => T_79[];
    set_: (<T_80>(value: T_80, index: number, arr: T_80[]) => T_80[]) & {
        <T_81>(value: T_81): {
            (index: number): (arr: T_81[]) => T_81[];
            (index: number, arr: T_81[]): T_81[];
        };
        <T_82>(value: T_82, index: number): (arr: T_82[]) => T_82[];
    };
    setSize_: (<T_83>(size: number, arr: T_83[]) => (T_83 | undefined)[]) & (<T_84>(size: number) => (arr: T_84[]) => (T_84 | undefined)[]);
    size_: <T_85>(arr: T_85[]) => number;
    slice: (<T_86>(from: number, to: number, arr: T_86[]) => T_86[]) & {
        <T_87>(from: number): {
            (to: number): (arr: T_87[]) => T_87[];
            (to: number, arr: T_87[]): T_87[];
        };
        <T_88>(from: number, to: number): (arr: T_88[]) => T_88[];
    } & {
        from: (<T_89>(from: number, arr: T_89[]) => T_89[]) & (<T_90>(from: number) => (arr: T_90[]) => T_90[]);
        to: (<T_91>(to: number, arr: T_91[]) => T_91[]) & (<T_92>(to: number) => (arr: T_92[]) => T_92[]);
    };
    some: (<T_93>(testFn: (element: T_93, index: number, arr: T_93[]) => boolean, arr: T_93[]) => boolean) & (<T_94>(testFn: (element: T_94, index: number, arr: T_94[]) => boolean) => (arr: T_94[]) => boolean);
    sort: (<T_95>(compareFn: (a: T_95, b: T_95) => number, arr: T_95[]) => T_95[]) & (<T_96>(compareFn: (a: T_96, b: T_96) => number) => (arr: T_96[]) => T_96[]) & {
        num(a: number[]): number[];
        numDesc(a: number[]): number[];
        str(a: string[]): string[];
        strDesc(a: string[]): string[];
        locale(a: string[]): string[];
        localeDesc(a: string[]): string[];
    };
    sortBy_: (<T_97, V_12>(compareFn: (a: V_12, b: V_12) => number, mappingFn: (element: T_97) => V_12, arr: T_97[]) => T_97[]) & {
        <T_98, V_13>(compareFn: (a: V_13, b: V_13) => number): {
            (mappingFn: (element: T_98) => V_13): (arr: T_98[]) => T_98[];
            (mappingFn: (element: T_98) => V_13, arr: T_98[]): T_98[];
        };
        <T_99, V_14>(compareFn: (a: V_14, b: V_14) => number, mappingFn: (element: T_99) => V_14): (arr: T_99[]) => T_99[];
    } & {
        num: {
            <T_100, V_15>(mappingFn: (element: T_100) => V_15): (arr: T_100[]) => T_100[];
            <T_101, V_16>(mappingFn: (element: T_101) => V_16, arr: T_101[]): T_101[];
        };
        numDesc: {
            <T_100, V_15>(mappingFn: (element: T_100) => V_15): (arr: T_100[]) => T_100[];
            <T_101, V_16>(mappingFn: (element: T_101) => V_16, arr: T_101[]): T_101[];
        };
        str: {
            <T_100, V_15>(mappingFn: (element: T_100) => V_15): (arr: T_100[]) => T_100[];
            <T_101, V_16>(mappingFn: (element: T_101) => V_16, arr: T_101[]): T_101[];
        };
        strDesc: {
            <T_100, V_15>(mappingFn: (element: T_100) => V_15): (arr: T_100[]) => T_100[];
            <T_101, V_16>(mappingFn: (element: T_101) => V_16, arr: T_101[]): T_101[];
        };
        locale: {
            <T_100, V_15>(mappingFn: (element: T_100) => V_15): (arr: T_100[]) => T_100[];
            <T_101, V_16>(mappingFn: (element: T_101) => V_16, arr: T_101[]): T_101[];
        };
        localeDesc: {
            <T_100, V_15>(mappingFn: (element: T_100) => V_15): (arr: T_100[]) => T_100[];
            <T_101, V_16>(mappingFn: (element: T_101) => V_16, arr: T_101[]): T_101[];
        };
    };
    toLocaleString: <T_102>(arr: T_102[]) => string;
    toString: <T_103>(arr: T_103[]) => string;
    update_: (<T_104>(updaterFn: (value: T_104) => T_104, index: number, arr: T_104[]) => T_104[]) & {
        <T_105>(updaterFn: (value: T_105) => T_105): {
            (index: number): (arr: T_105[]) => T_105[];
            (index: number, arr: T_105[]): T_105[];
        };
        <T_106>(reducingFn: (value: T_106) => T_106, index: number): (arr: T_106[]) => T_106[];
    };
    values: <T_107>(arr: T_107[]) => IterableIterator<T_107>;
    zip_: (<T_108, V_17>(otherArr: V_17[], arr: T_108[]) => [T_108, V_17][]) & (<T_109, V_18>(otherArr: V_18[]) => (arr: T_109[]) => [T_109, V_18][]) & {
        all: (<T_110, V_19>(otherArr: V_19[], arr: T_110[]) => [T_110 | undefined, V_19 | undefined][]) & (<T_111, V_20>(otherArr: V_20[]) => (arr: T_111[]) => [T_111 | undefined, V_20 | undefined][]);
    };
    zipWith_: (<T_112, V_21, X_6>(zippingFn: (otherArrItem: V_21, arrItem: T_112) => X_6, otherArr: V_21[], arr: T_112[]) => X_6[]) & {
        <T_113, V_22, X_7>(zippingFn: (otherArrItem: V_22, arrItem: T_113) => X_7): {
            (otherArr: V_22[]): (arr: T_113[]) => X_7[];
            (otherArr: V_22[], arr: T_113[]): X_7[];
        };
        <T_114, V_23, X_8>(zippingFn: (otherArrItem: V_23, arrItem: T_114) => X_8, otherArr: V_23[]): (arr: T_114[]) => X_8[];
    } & {
        all: (<T_115, V_24, X_9>(zippingFn: (otherArrItem: V_24 | undefined, arrItem: T_115 | undefined) => X_9, otherArr: V_24[], arr: T_115[]) => X_9[]) & {
            <T_116, V_25, X_10>(zippingFn: (otherArrItem: V_25 | undefined, arrItem: T_116 | undefined) => X_10): {
                (otherArr: V_25[]): (arr: T_116[]) => X_10[];
                (otherArr: V_25[], arr: T_116[]): X_10[];
            };
            <T_117, V_26, X_11>(zippingFn: (otherArrItem: V_26 | undefined, arrItem: T_117 | undefined) => X_11, otherArr: V_26[]): (arr: T_117[]) => X_11[];
        };
    };
};
export default _default;