Refactor TypeScript definition to use CJS compatible export

index.d.ts

@@ -1,71 +1,96 @@
-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;
-}
+declare namespace mem {
+	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;
+	interface Options<
+		ArgumentsType extends unknown[],
+		CacheKeyType extends unknown,
+		ReturnType extends unknown
+	> {
+		/**
+		Milliseconds until the cache expires.
 
-	/**
-	 * 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?: (...arguments: ArgumentsType) => CacheKeyType;
+		@default Infinity
+		*/
+		readonly maxAge?: number;
 
-	/**
-	 * 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>;
+		/**
+		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.
 
-	/**
-	 * Cache rejected promises.
-	 *
-	 * @default false
-	 */
-	readonly cachePromiseRejection?: boolean;
+		You could for example change it to only cache on the first argument `x => JSON.stringify(x)`.
+		*/
+		readonly cacheKey?: (...arguments: ArgumentsType) => CacheKeyType;
+
+		/**
+		Use a different cache storage. 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: {
+	/**
+	[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.
+
+	@example
+	```
+	import mem = require('mem');
+
+	let i = 0;
+	const counter = () => ++i;
+	const memoized = mem(counter);
+
+	memoized('foo');
+	//=> 1
+
+	// Cached as it's the same arguments
+	memoized('foo');
+	//=> 1
+
+	// Not cached anymore as the arguments changed
+	memoized('bar');
+	//=> 2
+
+	memoized('bar');
+	//=> 2
+	```
+	*/
 	<
 		ArgumentsType extends unknown[],
 		ReturnType extends unknown,
 		CacheKeyType extends unknown
 	>(
 		fn: (...arguments: ArgumentsType) => ReturnType,
-		options?: Options<ArgumentsType, CacheKeyType, ReturnType>
+		options?: mem.Options<ArgumentsType, CacheKeyType, ReturnType>
 	): (...arguments: ArgumentsType) => ReturnType;
 
 	/**
-	 * Clear all cached data of a memoized function.
-	 *
-	 * @param fn - Memoized function.
-	 */
+	Clear all cached data of a memoized function.
+
+	@param fn - Memoized function.
+	*/
 	clear<ArgumentsType extends unknown[], ReturnType extends unknown>(
 		fn: (...arguments: ArgumentsType) => ReturnType
 	): void;
+
+	// TODO: Remove this for the next major release
+	default: typeof mem;
 };
 
-export default mem;
+export = mem;

index.test-d.ts

@@ -1,5 +1,6 @@
-import {expectType} from 'tsd-check';
-import mem from '.';
+import {expectType} from 'tsd';
+// Following import syntax makes sure that type intellisense interop with plain JS isn't broken
+import mem = require('.');
 
 const fn = (string: string) => true;
 

package.json

@@ -13,7 +13,7 @@
 		"node": ">=6"
 	},
 	"scripts": {
-		"test": "xo && ava && tsd-check"
+		"test": "xo && ava && tsd"
 	},
 	"files": [
 		"index.js",
@@ -38,9 +38,9 @@
 		"p-is-promise": "^2.0.0"
 	},
 	"devDependencies": {
-		"ava": "^1.3.1",
+		"ava": "^1.4.1",
 		"delay": "^4.1.0",
-		"tsd-check": "^0.3.0",
+		"tsd": "^0.7.1",
 		"xo": "^0.24.0"
 	}
 }