'a'

mh-two-thousand-and-two

2024-04-12 44d2c92345cd156a59fc327b3060292a282d2893

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
declare namespace pMap {
    interface Options {
        /**
        Number of concurrently pending promises returned by `mapper`.
 
        @default Infinity
        */
        concurrency?: number;
    }
 
    /**
    Function which is called for every item in `input`. Expected to return a `Promise` or value.
 
    @param input - Iterated element.
    @param index - Index of the element in the source array.
    */
    type Mapper<Element = any, NewElement = any> = (
        input: Element,
        index: number
    ) => NewElement | Promise<NewElement>;
}
 
declare const pMap: {
    /**
    Returns a `Promise` that is fulfilled when all promises in `input` and ones returned from `mapper` are fulfilled, or rejects if any of the promises reject. The fulfilled value is an `Array` of the fulfilled values returned from `mapper` in `input` order.
 
    @param input - Iterated over concurrently in the `mapper` function.
    @param mapper - Function which is called for every item in `input`. Expected to return a `Promise` or value.
 
    @example
    ```
    import pMap = require('p-map');
    import got = require('got');
 
    const sites = [
        getWebsiteFromUsername('sindresorhus'), //=> Promise
        'ava.li',
        'todomvc.com',
        'github.com'
    ];
 
    (async () => {
        const mapper = async site => {
            const {requestUrl} = await got.head(site);
            return requestUrl;
        };
 
        const result = await pMap(sites, mapper, {concurrency: 2});
 
        console.log(result);
        //=> ['http://sindresorhus.com/', 'http://ava.li/', 'http://todomvc.com/', 'http://github.com/']
    })();
    ```
    */
    <Element, NewElement>(
        input: Iterable<Element>,
        mapper: pMap.Mapper<Element, NewElement>,
        options?: pMap.Options
    ): Promise<NewElement[]>;
 
    // TODO: Remove this for the next major release, refactor the whole definition to:
    // declare function pMap<Element, NewElement>(
    //     input: Iterable<Element>,
    //     mapper: pMap.Mapper<Element, NewElement>,
    //     options?: pMap.Options
    // ): Promise<NewElement[]>;
    // export = pMap;
    default: typeof pMap;
};
 
export = pMap;