Meta tweaks

.gitignore

@@ -1,3 +1,3 @@
 node_modules
 yarn.lock
-dist
+distribution

index.ts

@@ -97,15 +97,15 @@ export default function memoize<
 	FunctionToMemoize extends AnyFunction,
 	CacheKeyType,
 >(
-	fn: FunctionToMemoize,
+	function_: FunctionToMemoize,
 	{
 		cacheKey,
 		cache = new Map(),
 		maxAge,
 	}: Options<FunctionToMemoize, CacheKeyType> = {},
 ): FunctionToMemoize {
 	if (maxAge === 0) {
-		return fn;
+		return function_;
 	}
 
 	if (typeof maxAge === 'number') {
@@ -127,7 +127,7 @@ export default function memoize<
 			return cacheItem.data;
 		}
 
-		const result = fn.apply(this, arguments_) as ReturnType<FunctionToMemoize>;
+		const result = function_.apply(this, arguments_) as ReturnType<FunctionToMemoize>;
 
 		cache.set(key, {
 			data: result,
@@ -141,15 +141,15 @@ export default function memoize<
 
 			timer.unref?.();
 
-			const timers = cacheTimerStore.get(fn) ?? new Set<number>();
+			const timers = cacheTimerStore.get(function_) ?? new Set<number>();
 			timers.add(timer as unknown as number);
-			cacheTimerStore.set(fn, timers);
+			cacheTimerStore.set(function_, timers);
 		}
 
 		return result;
 	} as FunctionToMemoize;
 
-	mimicFunction(memoized, fn, {
+	mimicFunction(memoized, function_, {
 		ignoreNonConfigurable: true,
 	});
 
@@ -223,8 +223,8 @@ Clear all cached data of a memoized function.
 
 @param fn - The memoized function.
 */
-export function memoizeClear(fn: AnyFunction): void {
-	const cache = cacheStore.get(fn);
+export function memoizeClear(function_: AnyFunction): void {
+	const cache = cacheStore.get(function_);
 	if (!cache) {
 		throw new TypeError('Can\'t clear a function that was not memoized!');
 	}
@@ -235,7 +235,7 @@ export function memoizeClear(fn: AnyFunction): void {
 
 	cache.clear();
 
-	for (const timer of cacheTimerStore.get(fn) ?? []) {
+	for (const timer of cacheTimerStore.get(function_) ?? []) {
 		clearTimeout(timer);
 	}
 }

package.json

@@ -12,20 +12,20 @@
 	},
 	"type": "module",
 	"exports": {
-		"types": "./dist/index.d.ts",
-		"default": "./dist/index.js"
+		"types": "./distribution/index.d.ts",
+		"default": "./distribution/index.js"
 	},
 	"sideEffects": false,
 	"engines": {
 		"node": ">=18"
 	},
 	"scripts": {
-		"test": "xo && ava && npm run build && tsd --typings dist/index.d.ts",
-		"build": "del-cli dist && tsc",
+		"test": "xo && ava && npm run build && tsd --typings distribution/index.d.ts",
+		"build": "del-cli distribution && tsc",
 		"prepack": "npm run build"
 	},
 	"files": [
-		"dist"
+		"distribution"
 	],
 	"keywords": [
 		"memoize",
@@ -41,18 +41,18 @@
 		"promise"
 	],
 	"dependencies": {
-		"mimic-function": "^5.0.0"
+		"mimic-function": "^5.0.1"
 	},
 	"devDependencies": {
-		"@sindresorhus/tsconfig": "^5.0.0",
+		"@sindresorhus/tsconfig": "^6.0.0",
 		"@types/serialize-javascript": "^5.0.4",
-		"ava": "^5.3.1",
+		"ava": "^6.1.3",
 		"del-cli": "^5.1.0",
 		"delay": "^6.0.0",
-		"serialize-javascript": "^6.0.1",
-		"ts-node": "^10.9.1",
-		"tsd": "^0.29.0",
-		"xo": "^0.56.0"
+		"serialize-javascript": "^6.0.2",
+		"ts-node": "^10.9.2",
+		"tsd": "^0.31.1",
+		"xo": "^0.59.3"
 	},
 	"ava": {
 		"timeout": "1m",
@@ -61,7 +61,8 @@
 		},
 		"nodeArguments": [
 			"--loader=ts-node/esm"
-		]
+		],
+		"workerThreads": false
 	},
 	"xo": {
 		"rules": {

test-d/index.test-d.ts

@@ -2,35 +2,35 @@ import {expectType} from 'tsd';
 import memoize, {memoizeClear} from '../index.js';
 
 // eslint-disable-next-line unicorn/prefer-native-coercion-functions -- Required `string` type
-const fn = (text: string) => Boolean(text);
+const function_ = (text: string) => Boolean(text);
 
-expectType<typeof fn>(memoize(fn));
-expectType<typeof fn>(memoize(fn, {maxAge: 1}));
-expectType<typeof fn>(memoize(fn, {cacheKey: ([firstArgument]: [string]) => firstArgument}));
-expectType<typeof fn>(
-	memoize(fn, {
+expectType<typeof function_>(memoize(function_));
+expectType<typeof function_>(memoize(function_, {maxAge: 1}));
+expectType<typeof function_>(memoize(function_, {cacheKey: ([firstArgument]: [string]) => firstArgument}));
+expectType<typeof function_>(
+	memoize(function_, {
 		// The cacheKey returns an array. This isn't deduplicated by a regular Map, but it's valid. The correct solution would be to use ManyKeysMap to deduplicate it correctly
 		cacheKey: (arguments_: [string]) => arguments_,
 		cache: new Map<[string], {data: boolean; maxAge: number}>(),
 	}),
 );
-expectType<typeof fn>(
+expectType<typeof function_>(
 	// The `firstArgument` of `fn` is of type `string`, so it's used
-	memoize(fn, {cache: new Map<string, {data: boolean; maxAge: number}>()}),
+	memoize(function_, {cache: new Map<string, {data: boolean; maxAge: number}>()}),
 );
 
 /* Overloaded function tests */
-function overloadedFn(parameter: false): false;
-function overloadedFn(parameter: true): true;
-function overloadedFn(parameter: boolean): boolean {
+function overloadedFunction(parameter: false): false;
+function overloadedFunction(parameter: true): true;
+function overloadedFunction(parameter: boolean): boolean {
 	return parameter;
 }
 
-expectType<typeof overloadedFn>(memoize(overloadedFn));
-expectType<true>(memoize(overloadedFn)(true));
-expectType<false>(memoize(overloadedFn)(false));
+expectType<typeof overloadedFunction>(memoize(overloadedFunction));
+expectType<true>(memoize(overloadedFunction)(true));
+expectType<false>(memoize(overloadedFunction)(false));
 
-memoizeClear(fn);
+memoizeClear(function_);
 
 // `cacheKey` tests.
 // The argument should match the memoized function’s parameters

test.ts

@@ -193,7 +193,7 @@ test('prototype support', t => {
 	t.is(unicorn.foo(), 0);
 });
 
-test('.decorator()', t => {
+test('memoizeDecorator()', t => {
 	let returnValue = 1;
 	const returnValue2 = 101;
 
@@ -218,7 +218,7 @@ test('.decorator()', t => {
 	t.is(beta.counter(), 2, 'The method should not be memoized across instances');
 });
 
-test('memClear() throws when called with a plain function', t => {
+test('memoizeClear() throws when called with a plain function', t => {
 	t.throws(() => {
 		memoizeClear(() => {}); // eslint-disable-line @typescript-eslint/no-empty-function
 	}, {
@@ -227,7 +227,7 @@ test('memClear() throws when called with a plain function', t => {
 	});
 });
 
-test('memClear() throws when called on an unclearable cache', t => {
+test('memoizeClear() throws when called on an unclearable cache', t => {
 	const fixture = () => 1;
 	const memoized = memoize(fixture, {
 		cache: new WeakMap(),
@@ -281,10 +281,10 @@ test('maxAge - complex arguments and cache expiration', async t => {
 	const fixture = object => index++;
 	const memoized = memoize(fixture, {maxAge: 100, cacheKey: JSON.stringify});
 
-	const arg = {key: 'value'};
-	t.is(memoized(arg), 0);
+	const argument = {key: 'value'};
+	t.is(memoized(argument), 0);
 	await delay(150);
-	t.is(memoized(arg), 1); // Argument is the same, but should recompute due to expiration
+	t.is(memoized(argument), 1); // Argument is the same, but should recompute due to expiration
 });
 
 test('maxAge - concurrent calls return cached value', async t => {

tsconfig.json

@@ -1,7 +1,6 @@
 {
 	"extends": "@sindresorhus/tsconfig",
 	"compilerOptions": {
-		"outDir": "dist",
 		"experimentalDecorators": true
 	},
 	"files": [