Add TypeScript definition (#2)

index.d.ts

@@ -0,0 +1,69 @@
+declare namespace locatePath {
+	interface Options {
+		/**
+		Current working directory.
+
+		@default process.cwd()
+		*/
+		readonly cwd?: string;
+	}
+
+	interface AsyncOptions extends Options {
+		/**
+		Number of concurrently pending promises. Minimum: `1`.
+
+		@default Infinity
+		*/
+		readonly concurrency?: number;
+
+		/**
+		Preserve `input` 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 input - 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'
+	})();
+	```
+	*/
+	(input: Iterable<string>, options?: locatePath.AsyncOptions): Promise<
+		string | undefined
+	>;
+
+	/**
+	Synchronously get the first path that exists on disk of multiple paths.
+
+	@param input - Paths to check.
+	@returns The first path that exists or `undefined` if none exists.
+	*/
+	sync(
+		input: Iterable<string>,
+		options?: locatePath.Options
+	): string | undefined;
+};
+
+export = locatePath;

index.test-d.ts

@@ -0,0 +1,16 @@
+import {expectType} from 'tsd';
+import locatePath = require('.');
+
+const files = [
+	'unicorn.png',
+	'rainbow.png',
+	'pony.png'
+];
+
+expectType<Promise<string | undefined>>(locatePath(files));
+expectType<Promise<string | undefined>>(locatePath(files, {concurrency: 2}));
+expectType<Promise<string | undefined>>(locatePath(files, {preserveOrder: false}));
+expectType<Promise<string | undefined>>(locatePath(files, {cwd: '.'}));
+
+expectType<string | undefined>(locatePath.sync(files));
+expectType<string | undefined>(locatePath.sync(files, {cwd: '.'}));

package.json

@@ -13,10 +13,11 @@
 		"node": ">=6"
 	},
 	"scripts": {
-		"test": "xo && ava"
+		"test": "xo && ava && tsd"
 	},
 	"files": [
-		"index.js"
+		"index.js",
+		"index.d.ts"
 	],
 	"keywords": [
 		"locate",
@@ -38,7 +39,8 @@
 		"path-exists": "^3.0.0"
 	},
 	"devDependencies": {
-		"ava": "*",
-		"xo": "*"
+		"ava": "^1.4.1",
+		"tsd": "^0.7.2",
+		"xo": "^0.24.0"
 	}
 }

test.js

@@ -1,5 +1,5 @@
 import test from 'ava';
-import m from '.';
+import locatePath from '.';
 
 const input = [
 	'noop.foo',
@@ -9,13 +9,13 @@ const input = [
 ];
 
 test('async', async t => {
-	t.is(await m(input), 'index.js');
-	t.is(await m(['nonexistant']), undefined);
-	t.is(await m(['noop', 'unicorn'], {cwd: 'fixture'}), 'unicorn');
+	t.is(await locatePath(input), 'index.js');
+	t.is(await locatePath(['nonexistant']), undefined);
+	t.is(await locatePath(['noop', 'unicorn'], {cwd: 'fixture'}), 'unicorn');
 });
 
 test('sync', t => {
-	t.is(m.sync(input), 'index.js');
-	t.is(m.sync(['nonexistant']), undefined);
-	t.is(m.sync(['noop', 'unicorn'], {cwd: 'fixture'}), 'unicorn');
+	t.is(locatePath.sync(input), 'index.js');
+	t.is(locatePath.sync(['nonexistant']), undefined);
+	t.is(locatePath.sync(['noop', 'unicorn'], {cwd: 'fixture'}), 'unicorn');
 });