Add TypeScript definition (#28)

index.d.ts

@@ -0,0 +1,71 @@
+export interface CacheStorage<
+	KeyType extends unknown,
+	ValueType extends unknown
+> {
+	has(key: KeyType): boolean;
+	get(key: KeyType): ValueType | undefined;
+	set(key: KeyType, value: ValueType): void;
+	delete(key: KeyType): void;
+	clear?: () => void;
+}
+
+export interface Options<
+	ArgumentsType extends unknown[],
+	CacheKeyType extends unknown,
+	ReturnType extends unknown
+> {
+	/**
+	 * Milliseconds until the cache expires.
+	 *
+	 * @default Infinity
+	 */
+	readonly maxAge?: number;
+
+	/**
+	 * Determines the cache key for storing the result based on the function arguments. By default, if there's only one argument and it's a [primitive](https://developer.mozilla.org/en-US/docs/Glossary/Primitive), it's used directly as a key, otherwise it's all the function arguments JSON stringified as an array.
+	 *
+	 * You could for example change it to only cache on the first argument `x => JSON.stringify(x)`.
+	 */
+	readonly cacheKey?: (...args: ArgumentsType) => CacheKeyType;
+
+	/**
+	 * Use a different cache storage. Must implement the following methods: `.has(key)`, `.get(key)`, `.set(key, value)`, `.delete(key)`, and optionally `.clear()`. You could for example use a `WeakMap` instead or [`quick-lru`](https://github.com/sindresorhus/quick-lru) for a LRU cache.
+	 *
+	 * @default new Map()
+	 */
+	readonly cache?: CacheStorage<CacheKeyType, ReturnType>;
+
+	/**
+	 * Cache rejected promises.
+	 *
+	 * @default false
+	 */
+	readonly cachePromiseRejection?: boolean;
+}
+
+/**
+ * [Memoize](https://en.wikipedia.org/wiki/Memoization) functions - An optimization used to speed up consecutive function calls by caching the result of calls with identical input.
+ *
+ * @param fn - Function to be memoized.
+ */
+declare const mem: {
+	<
+		ArgumentsType extends unknown[],
+		ReturnType extends unknown,
+		CacheKeyType extends unknown
+	>(
+		fn: (...arguments: ArgumentsType) => ReturnType,
+		options?: Options<ArgumentsType, CacheKeyType, ReturnType>
+	): (...arguments: ArgumentsType) => ReturnType;
+
+	/**
+	 * Clear all cached data of a memoized function.
+	 *
+	 * @param fn - Memoized function.
+	 */
+	clear<ArgumentsType extends unknown[], ReturnType extends unknown>(
+		fn: (...arguments: ArgumentsType) => ReturnType
+	): void;
+};
+
+export default mem;

index.js

@@ -24,7 +24,7 @@ const defaultCacheKey = (...args) => {
 	return JSON.stringify(args);
 };
 
-module.exports = (fn, options) => {
+const mem = (fn, options) => {
 	options = Object.assign({
 		cacheKey: defaultCacheKey,
 		cache: new Map(),
@@ -77,6 +77,9 @@ module.exports = (fn, options) => {
 	return memoized;
 };
 
+module.exports = mem;
+module.exports.default = mem;
+
 module.exports.clear = fn => {
 	const cache = cacheStore.get(fn);
 

index.test-d.ts

@@ -0,0 +1,17 @@
+import {expectType} from 'tsd-check';
+import mem from '.';
+
+const fn = (string: string) => true;
+
+expectType<(string: string) => boolean>(mem(fn));
+expectType<(string: string) => boolean>(mem(fn, {maxAge: 1}));
+expectType<(string: string) => boolean>(mem(fn, {cacheKey: (...args) => args}));
+expectType<(string: string) => boolean>(
+	mem(fn, {cacheKey: (...args) => args, cache: new Map<[string], boolean>()})
+);
+expectType<(string: string) => boolean>(
+	mem(fn, {cache: new Map<[string], boolean>()})
+);
+expectType<(string: string) => boolean>(mem(fn, {cachePromiseRejection: true}));
+
+mem.clear(fn);

package.json

@@ -13,10 +13,11 @@
 		"node": ">=6"
 	},
 	"scripts": {
-		"test": "xo && ava"
+		"test": "xo && ava && tsd-check"
 	},
 	"files": [
-		"index.js"
+		"index.js",
+		"index.d.ts"
 	],
 	"keywords": [
 		"memoize",
@@ -37,8 +38,9 @@
 		"p-is-promise": "^2.0.0"
 	},
 	"devDependencies": {
-		"ava": "^1.0.1",
+		"ava": "^1.3.1",
 		"delay": "^4.1.0",
-		"xo": "^0.23.0"
+		"tsd-check": "^0.3.0",
+		"xo": "^0.24.0"
 	}
 }

test.js

@@ -78,6 +78,7 @@ test('maxAge option deletes old items', async t => {
 		deleted.push(item);
 		return remove(item);
 	};
+
 	const memoized = mem(f, {maxAge: 100, cache});
 	t.is(memoized(1), 0);
 	t.is(memoized(1), 0);
@@ -97,8 +98,10 @@ test('maxAge items are deleted even if function throws', async t => {
 		if (i === 1) {
 			throw new Error('failure');
 		}
+
 		return i++;
 	};
+
 	const cache = new Map();
 	const memoized = mem(f, {maxAge: 100, cache});
 	t.is(memoized(1), 0);
@@ -188,7 +191,7 @@ test('cache rejected promises if enabled', async t => {
 });
 
 test('preserves the original function name', t => {
-	t.is(mem(function foo() {}).name, 'foo'); // eslint-disable-line func-names, prefer-arrow-callback
+	t.is(mem(function foo() {}).name, 'foo'); // eslint-disable-line func-names
 });
 
 test('.clear()', t => {
@@ -210,6 +213,7 @@ test('prototype support', t => {
 	const Unicorn = function () {
 		this.i = 0;
 	};
+
 	Unicorn.prototype.foo = mem(f);
 
 	const unicorn = new Unicorn();