source control 1.1

Tomas

2022-05-19 957a1f10a06fdbb76f1a0ba94fe44126c613fee3

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
72
73
74
75
76
77
78
79
80
81
82
83
declare namespace locatePath {
    interface Options {
        /**
        Current working directory.
 
        @default process.cwd()
        */
        readonly cwd?: string;
 
        /**
        Type of path to match.
 
        @default 'file'
        */
        readonly type?: 'file' | 'directory';
 
        /**
        Allow symbolic links to match if they point to the requested path type.
 
        @default true
        */
        readonly allowSymlinks?: boolean;
    }
 
    interface AsyncOptions extends Options {
        /**
        Number of concurrently pending promises. Minimum: `1`.
 
        @default Infinity
        */
        readonly concurrency?: number;
 
        /**
        Preserve `paths` order when searching.
 
        Disable this to improve performance if you don't care about the order.
 
        @default true
        */
        readonly preserveOrder?: boolean;
    }
}
 
declare const locatePath: {
    /**
    Get the first path that exists on disk of multiple paths.
 
    @param paths - Paths to check.
    @returns The first path that exists or `undefined` if none exists.
 
    @example
    ```
    import locatePath = require('locate-path');
 
    const files = [
        'unicorn.png',
        'rainbow.png', // Only this one actually exists on disk
        'pony.png'
    ];
 
    (async () => {
        console(await locatePath(files));
        //=> 'rainbow'
    })();
    ```
    */
    (paths: Iterable<string>, options?: locatePath.AsyncOptions): Promise<
        string | undefined
    >;
 
    /**
    Synchronously get the first path that exists on disk of multiple paths.
 
    @param paths - Paths to check.
    @returns The first path that exists or `undefined` if none exists.
    */
    sync(
        paths: Iterable<string>,
        options?: locatePath.Options
    ): string | undefined;
};
 
export = locatePath;