rename matchesArg to isArgEqual and matchesKey to isKeyEqual to be more declarative

Author: planttheidea

DEV_ONLY/index.ts

@@ -81,7 +81,7 @@ console.groupEnd();
 console.group('maxArgs');
 
 const memoizedMax = memoize(method, {
-  matchesKey: (originalKey, newKey) => originalKey[0] === newKey[0],
+  isKeyEqual: (originalKey, newKey) => originalKey[0] === newKey[0],
 });
 
 memoizedMax(foo, bar);
@@ -105,7 +105,7 @@ const deepEqualMethod = ({
 };
 
 const deepEqualMemoized = memoize(deepEqualMethod, {
-  matchesArg: deepEqual,
+  isArgEqual: deepEqual,
 });
 
 deepEqualMemoized({ one: 1, two: 2 });
@@ -208,7 +208,7 @@ const noFns = (one: string, two: string, three: Function) => {
 };
 
 const memoizedNoFns = memoize(noFns, {
-  matchesArg(key1, key2) {
+  isArgEqual(key1, key2) {
     return key1 === key2;
   },
   transformKey(args) {
@@ -233,7 +233,7 @@ const matchingKeyMethod = function (object: {
 };
 
 const matchingKeyMemoized = memoize(matchingKeyMethod, {
-  matchesKey: deepEqual,
+  isKeyEqual: deepEqual,
   maxSize: 10,
 });
 

README.md

@@ -12,8 +12,8 @@ A tiny, crazy [fast](#benchmarks) memoization library for the 95% use-case
     - [Composition](#composition)
   - [Options](#options)
     - [async](#async)
-    - [matchesArg](#matchesarg)
-    - [matchesKey](#matcheskey)
+    - [isArgEqual](#matchesarg)
+    - [isKeyEqual](#matcheskey)
     - [maxSize](#maxsize)
     - [transformKey](#transformkey)
   - [Cache](#cache)
@@ -72,7 +72,7 @@ Starting in `4.0.0`, you can compose memoized functions if you want to have mult
 ```ts
 const simple = memoized(fn); // { maxSize: 1 }
 const upToFive = memoized(simple, { maxSize: 5 }); // { maxSize: 5 }
-const withCustomEquals = memoized(upToFive, { matchesArg: deepEqual }); // { maxSize: 5, matchesArg: deepEqual }
+const withCustomEquals = memoized(upToFive, { isArgEqual: deepEqual }); // { maxSize: 5, isArgEqual: deepEqual }
 ```
 
 **NOTE**: The original function is the function used in the composition, the composition only applies to the options. In the example above, `upToFive` does not call `simple`, it calls `fn`.
@@ -110,7 +110,7 @@ setTimeout(() => {
 
 **NOTE**: If you don't want rejections to auto-remove the entry from cache, set `async` to `false` (or simply do not set it), but be aware this will also remove the cache listeners that fire on successful resolution.
 
-### matchesArg
+### isArgEqual
 
 `function(arg1: any, arg2: any): boolean`, _defaults to `isSameValueZero`_
 
@@ -136,7 +136,7 @@ const deepObject = (object: {
   bar: object.bar,
 });
 
-const memoizedDeepObject = memoize(deepObject, { matchesArg: deepEqual });
+const memoizedDeepObject = memoize(deepObject, { isArgEqual: deepEqual });
 
 console.log(
   memoizedDeepObject({
@@ -169,7 +169,7 @@ console.log(
 
 **NOTE**: The default method tests for [SameValueZero](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) equality, which is summarized as strictly equal while also considering `NaN` equal to `NaN`.
 
-### matchesKey
+### isKeyEqual
 
 `function(existingKey: any[], passedKey: any[]): boolean`
 
@@ -193,7 +193,7 @@ const deepObject = (object: ContrivedObject) => ({
 
 const memoizedShape = memoize(deepObject, {
   // receives the full key in cache and the full key of the most recent call
-  matchesKey(key1, key2) {
+  isKeyEqual(key1, key2) {
     const object1 = key1[0];
     const object2 = key2[0];
 
@@ -261,13 +261,13 @@ console.log(memoized('one', () => {})); // ['one', () => {}]
 console.log(memoized('one', () => {})); // pulled from cache, ['one', () => {}]
 ```
 
-If your transformed keys require something other than `SameValueZero` equality, you can combine `transformKey` with [`matchesArg`](#isequal) for completely custom key creation and comparison.
+If your transformed keys require something other than `SameValueZero` equality, you can combine `transformKey` with [`isArgEqual`](#isequal) for completely custom key creation and comparison.
 
 ```ts
 const ignoreFunctionArg = (one: string, two: () => void) => [one, two];
 
 const memoized = memoize(ignoreFunctionArg, {
-  matchesKey: (key1, key2) => key1[0] === key2[0],
+  isKeyEqual: (key1, key2) => key1[0] === key2[0],
   // Cache based on the serialized first parameter
   transformKey: (args) => [JSON.stringify(args[0])],
 });

__tests__/index.ts

@@ -200,7 +200,7 @@ describe('memoize', () => {
     ]);
   });
 
-  it('will return the memoized function that will use the custom matchesArg method', () => {
+  it('will return the memoized function that will use the custom isArgEqual method', () => {
     let callCount = 0;
 
     const fn = (one: any, two: any) => {
@@ -212,9 +212,9 @@ describe('memoize', () => {
       };
     };
 
-    const memoized = memoize(fn, { matchesArg: deepEqual });
+    const memoized = memoize(fn, { isArgEqual: deepEqual });
 
-    expect(memoized.options.matchesArg).toBe(deepEqual);
+    expect(memoized.options.isArgEqual).toBe(deepEqual);
 
     expect(
       memoized(
@@ -292,7 +292,7 @@ describe('memoize', () => {
     ]);
   });
 
-  it('will return the memoized function that will use the transformKey method with a custom matchesArg', () => {
+  it('will return the memoized function that will use the transformKey method with a custom isArgEqual', () => {
     let callCount = 0;
 
     const fn = (one: any, two: any) => {
@@ -303,7 +303,7 @@ describe('memoize', () => {
         two,
       };
     };
-    const matchesArg = function (key1: any, key2: any) {
+    const isArgEqual = function (key1: any, key2: any) {
       return key1.args === key2.args;
     };
     const transformKey = function (args: any[]) {
@@ -315,11 +315,11 @@ describe('memoize', () => {
     };
 
     const memoized = memoize(fn, {
-      matchesArg,
+      isArgEqual,
       transformKey,
     });
 
-    expect(memoized.options.matchesArg).toBe(matchesArg);
+    expect(memoized.options.isArgEqual).toBe(isArgEqual);
     expect(memoized.options.transformKey).toBe(transformKey);
 
     const fnArg1 = () => {};
@@ -627,14 +627,14 @@ describe('memoize', () => {
     const fn = () => {};
 
     const maxSize = 5;
-    const matchesArg = () => true;
+    const isArgEqual = () => true;
 
     const memoized = memoize(fn, { maxSize });
-    const reMemoized = memoize(memoized, { matchesArg });
+    const reMemoized = memoize(memoized, { isArgEqual });
 
     expect(reMemoized).not.toBe(memoized);
     expect(reMemoized.options.maxSize).toBe(maxSize);
-    expect(reMemoized.options.matchesArg).toBe(matchesArg);
+    expect(reMemoized.options.isArgEqual).toBe(isArgEqual);
   });
 
   it('will throw an error if not a function', () => {
@@ -656,7 +656,7 @@ describe('memoize', () => {
       expect(result2).toBe(result1);
     });
 
-    it('matches for option `matchesArg`', () => {
+    it('matches for option `isArgEqual`', () => {
       type ContrivedObject = {
         deep: string;
       };
@@ -670,7 +670,7 @@ describe('memoize', () => {
         bar: object.bar,
       });
 
-      const memoizedDeepObject = memoize(deepObject, { matchesArg: deepEqual });
+      const memoizedDeepObject = memoize(deepObject, { isArgEqual: deepEqual });
 
       const result1 = memoizedDeepObject({
         foo: {
@@ -702,7 +702,7 @@ describe('memoize', () => {
       expect(result2).toBe(result1);
     });
 
-    it('matches for option `matchesKey`', () => {
+    it('matches for option `isKeyEqual`', () => {
       type ContrivedObject = { foo: string; bar: number; baz: string };
 
       const deepObject = (object: ContrivedObject) => ({
@@ -712,7 +712,7 @@ describe('memoize', () => {
 
       const memoizedShape = memoize(deepObject, {
         // receives the full key in cache and the full key of the most recent call
-        matchesKey(key1, key2) {
+        isKeyEqual(key1, key2) {
           const object1 = key1[0];
           const object2 = key2[0];
 
@@ -949,7 +949,7 @@ describe('memoize', () => {
       }));
 
       const memoized = memoize(ignoreFunctionArg, {
-        matchesKey: (key1, key2) => key1[0] === key2[0],
+        isKeyEqual: (key1, key2) => key1[0] === key2[0],
         // Cache based on the serialized first parameter
         transformKey: (args) => [
           JSON.stringify(args, (_key: string, value: any) =>

benchmarks/index.cjs

@@ -29,7 +29,7 @@ const lruMemoize = require('lru-memoize').default;
 const mem = require('mem');
 const memoizee = require('memoizee');
 const memoizerific = require('memoizerific');
-const memoize = require('../dist/micro-memoize.cjs.js').default;
+const memoize = require('../dist/cjs/index.cjs').default;
 const ramda = require('ramda').memoizeWith(resolveArguments);
 const underscore = require('underscore').memoize;
 

index.d.ts

@@ -1,6 +1,6 @@
 import type { Memoize } from './dist/umd/types/internalTypes.d';
 
-export * from './dist/umd/types/internalTypes.d';
+export type * from './dist/umd/types/internalTypes.d';
 export type { Cache } from './dist/umd/types/Cache.d';
 
 /**

package.json

@@ -98,13 +98,12 @@
     "url": "git+https://github.com/planttheidea/micro-memoize.git"
   },
   "scripts": {
-    "benchmark": "npm run clean && npm run build && NODE_ENV=production node ./benchmarks/index.cjs",
+    "benchmark": "npm run build:cjs && NODE_ENV=production node ./benchmarks/index.cjs",
     "build": "npm run build:esm && npm run build:cjs && npm run build:umd && npm run build:min",
     "build:cjs": "rimraf dist/cjs && NODE_ENV=production rollup -c build/rollup/config.cjs.js && tsc -p ./build/tsconfig/cjs.json",
     "build:esm": "rimraf dist/esm && NODE_ENV=production rollup -c build/rollup/config.esm.js && tsc -p ./build/tsconfig/esm.json",
     "build:min": "rimraf dist/min && NODE_ENV=production rollup -c build/rollup/config.min.js && tsc -p ./build/tsconfig/min.json",
     "build:umd": "rimraf dist/umd && NODE_ENV=production rollup -c build/rollup/config.umd.js && tsc -p ./build/tsconfig/umd.json",
-    "clean": "rimraf dist && rimraf mjs",
     "dev": "NODE_ENV=development webpack-dev-server --config=build/webpack.config.js",
     "lint": "NODE_ENV=test eslint src/*.ts",
     "lint:fix": "npm run lint -- --fix",

src/Cache.ts

@@ -30,12 +30,12 @@ export class Cache<Fn extends (...args: any[]) => any> {
   constructor(options: Options<Fn>) {
     const transformKey = getDefault('function', options.transformKey);
 
-    this.a = getDefault('function', options.matchesArg, isSameValueZero);
+    this.a = getDefault('function', options.isArgEqual, isSameValueZero);
     this.l = getDefault('number', options.maxSize, 1);
-    this.m = getDefault('function', options.matchesKey, this.e);
+    this.m = getDefault('function', options.isKeyEqual, this.e);
     this.p = getDefault('boolean', options.async, false);
 
-    if (transformKey || options.matchesKey === this.m) {
+    if (transformKey || options.isKeyEqual === this.m) {
       this.k = transformKey
         ? (args: IArguments | Key) => transformKey(cloneKey<Fn>(args))
         : cloneKey;

src/index.ts

@@ -2,6 +2,10 @@ import type { Key, Memoize, Memoized, Options } from './internalTypes';
 import { Cache } from './Cache';
 import { cloneKey, isMemoized } from './utils';
 
+export type * from './internalTypes';
+
+export { Cache };
+
 const memoize: Memoize = function memoize<
   Fn extends (...args: any[]) => any,
   Opts extends Options<Fn>,
@@ -19,16 +23,15 @@ const memoize: Memoize = function memoize<
     return memoize(fn.fn, Object.assign({}, fn.options, passedOptions));
   }
 
-  const cache = new Cache(passedOptions);
-
   const memoized: Memoized<Fn, Opts> = function memoized(this: any) {
-    const { h: head, k: transformKey } = cache;
+    const cache = memoized.cache;
+    const transformKey = cache.k;
     const key = transformKey
       ? transformKey(arguments)
       : (arguments as unknown as Key);
     let node = cache.g(key);
 
-    if (node === head) {
+    if (node === cache.h) {
       cache.oh && cache.oh.n(node);
     } else if (node) {
       cache.u(node);
@@ -46,14 +49,12 @@ const memoize: Memoize = function memoize<
     return node.v;
   };
 
-  memoized.cache = cache;
+  memoized.cache = new Cache(passedOptions);
   memoized.fn = fn;
   memoized.isMemoized = true;
   memoized.options = passedOptions;
 
   return memoized;
 };
 
-memoize.Cache = Cache;
-
 export default memoize;