Add TypeScript definition (#18)

index.d.ts

@@ -0,0 +1,107 @@
+declare namespace mapObject {
+	type Mapper<
+		SourceObjectType extends {[key: string]: unknown},
+		MappedObjectKeyType extends string,
+		MappedObjectValueType extends unknown
+	> = (
+		sourceKey: keyof SourceObjectType,
+		sourceValue: SourceObjectType[keyof SourceObjectType],
+		source: SourceObjectType
+	) => [MappedObjectKeyType, MappedObjectValueType];
+
+	interface Options {
+		/**
+		Recurse nested objects and objects in arrays.
+
+		@default false
+		*/
+		deep?: boolean;
+
+		/**
+		Target object to map properties on to.
+
+		@default {}
+		*/
+		target?: {[key: string]: unknown};
+	}
+
+	interface DeepOptions extends Options {
+		deep: true;
+	}
+
+	interface TargetOptions<TargetObjectType extends {[key: string]: unknown}>
+		extends Options {
+		target: TargetObjectType;
+	}
+}
+
+/**
+Map object keys and values into a new object.
+
+@param source - Source object to copy properties from.
+@param mapper - Mapping function.
+
+@example
+```
+import mapObject = require('map-obj');
+
+const newObject = mapObject({foo: 'bar'}, (key, value) => [value, key]);
+//=> {bar: 'foo'}
+```
+*/
+declare function mapObject<
+	SourceObjectType extends object,
+	TargetObjectType extends {[key: string]: unknown},
+	MappedObjectKeyType extends string,
+	MappedObjectValueType extends unknown = unknown
+>(
+	source: SourceObjectType,
+	mapper: mapObject.Mapper<
+		SourceObjectType,
+		MappedObjectKeyType,
+		MappedObjectValueType
+	>,
+	options: mapObject.DeepOptions & mapObject.TargetOptions<TargetObjectType>
+): TargetObjectType & {[key: string]: unknown};
+declare function mapObject<
+	SourceObjectType extends object,
+	MappedObjectKeyType extends string,
+	MappedObjectValueType extends unknown = unknown
+>(
+	source: SourceObjectType,
+	mapper: mapObject.Mapper<
+		SourceObjectType,
+		MappedObjectKeyType,
+		MappedObjectValueType
+	>,
+	options: mapObject.DeepOptions
+): {[key: string]: unknown};
+declare function mapObject<
+	SourceObjectType extends {[key: string]: unknown},
+	TargetObjectType extends {[key: string]: unknown},
+	MappedObjectKeyType extends string,
+	MappedObjectValueType extends unknown
+>(
+	source: SourceObjectType,
+	mapper: mapObject.Mapper<
+		SourceObjectType,
+		MappedObjectKeyType,
+		MappedObjectValueType
+	>,
+	options: mapObject.TargetOptions<TargetObjectType>
+): TargetObjectType & {[K in MappedObjectKeyType]: MappedObjectValueType};
+declare function mapObject<
+	SourceObjectType extends {[key: string]: unknown},
+	MappedObjectKeyType extends string,
+	MappedObjectValueType extends unknown = unknown
+>(
+	source: SourceObjectType,
+	mapper: mapObject.Mapper<
+		SourceObjectType,
+		MappedObjectKeyType,
+		MappedObjectValueType
+	>,
+	options?: mapObject.Options
+): {[K in MappedObjectKeyType]: MappedObjectValueType};
+
+export = mapObject;

index.js

@@ -8,7 +8,7 @@ const isObject = x =>
 	!(x instanceof Error) &&
 	!(x instanceof Date);
 
-module.exports = function mapObj(object, fn, options, seen) {
+const mapObject = (object, fn, options, seen) => {
 	options = Object.assign({
 		deep: false,
 		target: {}
@@ -25,7 +25,7 @@ module.exports = function mapObj(object, fn, options, seen) {
 	const {target} = options;
 	delete options.target;
 
-	const mapArray = array => array.map(x => isObject(x) ? mapObj(x, fn, options, seen) : x);
+	const mapArray = array => array.map(x => isObject(x) ? mapObject(x, fn, options, seen) : x);
 	if (Array.isArray(object)) {
 		return mapArray(object);
 	}
@@ -38,11 +38,13 @@ module.exports = function mapObj(object, fn, options, seen) {
 		if (options.deep && isObject(newValue)) {
 			newValue = Array.isArray(newValue) ?
 				mapArray(newValue) :
-				mapObj(newValue, fn, options, seen);
+				mapObject(newValue, fn, options, seen);
 		}
 
 		target[newKey] = newValue;
 	}
 
 	return target;
 };
+
+module.exports = mapObject;

index.test-d.ts

@@ -0,0 +1,34 @@
+import {expectType} from 'tsd';
+import mapObject = require('.');
+
+const options: mapObject.Options = {};
+
+const newObject = mapObject({foo: 'bar'}, (key, value) => [value, key]);
+expectType<{[x: string]: 'foo'}>(newObject);
+expectType<'foo'>(newObject.bar);
+
+const obj = mapObject({foo: 'bar'}, (key, value) => [value, key], {
+	target: {baz: 'baz'}
+});
+expectType<{baz: string} & {[x: string]: 'foo'}>(obj);
+expectType<'foo'>(obj.bar);
+expectType<string>(obj.baz);
+
+const obj1 = mapObject({foo: 'bar'}, (key, value) => [value, key], {
+	target: {baz: 'baz'},
+	deep: false
+});
+expectType<{baz: string} & {[x: string]: 'foo'}>(obj1);
+expectType<'foo'>(obj1.bar);
+expectType<string>(obj1.baz);
+
+const obj2 = mapObject({foo: 'bar'}, (key, value) => [value, key], {
+	deep: true
+});
+expectType<{[key: string]: unknown}>(obj2);
+const obj3 = mapObject({foo: 'bar'}, (key, value) => [value, key], {
+	deep: true,
+	target: {bar: 'baz' as const}
+});
+expectType<{[key: string]: unknown}>(obj3);
+expectType<'baz'>(obj3.bar);

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": [
 		"map",
@@ -36,7 +37,8 @@
 		"recursive"
 	],
 	"devDependencies": {
-		"ava": "*",
-		"xo": "*"
+		"ava": "^1.4.1",
+		"tsd": "^0.7.2",
+		"xo": "^0.24.0"
 	}
 }

readme.md

@@ -13,20 +13,20 @@ $ npm install map-obj
 ## Usage
 
 ```js
-const mapObj = require('map-obj');
+const mapObject = require('map-obj');
 
-const newObject = mapObj({foo: 'bar'}, (key, value) => [value, key]);
+const newObject = mapObject({foo: 'bar'}, (key, value) => [value, key]);
 //=> {bar: 'foo'}
 ```
 
 
 ## API
 
-### mapObj(source, mapper, [options])
+### mapObject(source, mapper, [options])
 
 #### source
 
-Type: `Object`
+Type: `object`
 
 Source object to copy properties from.
 
@@ -41,7 +41,7 @@ Mapping function.
 
 #### options
 
-Type: `Object`
+Type: `object`
 
 ##### deep
 
@@ -52,7 +52,7 @@ Recurse nested objects and objects in arrays.
 
 ##### target
 
-Type: `Object`<br>
+Type: `object`<br>
 Default: `{}`
 
 Target object to map properties on to.