memoize-id - npm Package Compare versions

Comparing version 0.2.0 to 1.0.0

lib/__tests__/memoize-test.js

@@ -1,11 +0,11 @@
-'use strict';
+"use strict";
 
-function _asyncToGenerator(fn) { return function () { var gen = fn.apply(this, arguments); return new Promise(function (resolve, reject) { function step(key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { return Promise.resolve(value).then(function (value) { return step("next", value); }, function (err) { return step("throw", err); }); } } return step("next"); }); }; }
-
 jest.dontMock('../index');
-var memoize = require('../index').default;
 
-describe('memoize', function () {
-  it('memoizes when no arguments are passed', function () {
-    var i = 0;
+const memoize = require('../index').default;
+
+describe('memoize', () => {
+  it('memoizes when no arguments are passed', () => {
+    let i = 0;
+
     function fn() {
@@ -15,3 +15,4 @@ i += 1;
     }
-    var memoizedFn = memoize(fn);
+
+    const memoizedFn = memoize(fn);
     expect(i).toBe(0);
@@ -22,5 +23,5 @@ expect(memoizedFn()).toBe(1);
   });
+  it('memoizes when one argument is passed', () => {
+    let i = 0;
 
-  it('memoizes when one argument is passed', function () {
-    var i = 0;
     function fn(foo) {
@@ -30,19 +31,32 @@ i += 1;
         arg: foo,
-        i: i
+        i
       };
     }
-    var memoizedFn = memoize(fn);
+
+    const memoizedFn = memoize(fn);
     expect(i).toBe(0);
-    expect(memoizedFn()).toEqual({ arg: undefined, i: 1 });
+    expect(memoizedFn()).toEqual({
+      arg: undefined,
+      i: 1
+    });
     expect(i).toBe(1);
-    expect(memoizedFn()).toEqual({ arg: undefined, i: 1 });
+    expect(memoizedFn()).toEqual({
+      arg: undefined,
+      i: 1
+    });
     expect(i).toBe(1);
-    expect(memoizedFn('foo')).toEqual({ arg: 'foo', i: 2 });
+    expect(memoizedFn('foo')).toEqual({
+      arg: 'foo',
+      i: 2
+    });
     expect(i).toBe(2);
-    expect(memoizedFn('foo')).toEqual({ arg: 'foo', i: 2 });
+    expect(memoizedFn('foo')).toEqual({
+      arg: 'foo',
+      i: 2
+    });
     expect(i).toBe(2);
   });
+  it('memoizes when three arguments are passed', () => {
+    let i = 0;
 
-  it('memoizes when three arguments are passed', function () {
-    var i = 0;
     function fn(foo, bar, baz) {
@@ -52,21 +66,37 @@ i += 1;
         args: [foo, bar, baz],
-        i: i
+        i
       };
     }
-    var memoizedFn = memoize(fn);
+
+    const memoizedFn = memoize(fn);
     expect(i).toBe(0);
-    expect(memoizedFn()).toEqual({ args: [undefined, undefined, undefined], i: 1 });
+    expect(memoizedFn()).toEqual({
+      args: [undefined, undefined, undefined],
+      i: 1
+    });
     expect(i).toBe(1);
-    expect(memoizedFn()).toEqual({ args: [undefined, undefined, undefined], i: 1 });
+    expect(memoizedFn()).toEqual({
+      args: [undefined, undefined, undefined],
+      i: 1
+    });
     expect(i).toBe(1);
-    expect(memoizedFn('foo', 'bar', 'baz')).toEqual({ args: ['foo', 'bar', 'baz'], i: 2 });
+    expect(memoizedFn('foo', 'bar', 'baz')).toEqual({
+      args: ['foo', 'bar', 'baz'],
+      i: 2
+    });
     expect(i).toBe(2);
-    expect(memoizedFn('foo', 'bar', 'baz')).toEqual({ args: ['foo', 'bar', 'baz'], i: 2 });
+    expect(memoizedFn('foo', 'bar', 'baz')).toEqual({
+      args: ['foo', 'bar', 'baz'],
+      i: 2
+    });
     expect(i).toBe(2);
-    expect(memoizedFn('foo', 'qux', 'baz')).toEqual({ args: ['foo', 'qux', 'baz'], i: 3 });
+    expect(memoizedFn('foo', 'qux', 'baz')).toEqual({
+      args: ['foo', 'qux', 'baz'],
+      i: 3
+    });
     expect(i).toBe(3);
   });
+  it('memoizes when three object arguments are passed', () => {
+    let i = 0;
 
-  it('memoizes when three object arguments are passed', function () {
-    var i = 0;
     function fn(foo, bar, baz) {
@@ -76,20 +106,51 @@ i += 1;
         args: [foo, bar, baz],
-        i: i
+        i
       };
     }
-    var memoizedFn = memoize(fn);
+
+    const memoizedFn = memoize(fn);
     expect(i).toBe(0);
-    expect(memoizedFn()).toEqual({ args: [undefined, undefined, undefined], i: 1 });
+    expect(memoizedFn()).toEqual({
+      args: [undefined, undefined, undefined],
+      i: 1
+    });
     expect(i).toBe(1);
-    expect(memoizedFn()).toEqual({ args: [undefined, undefined, undefined], i: 1 });
+    expect(memoizedFn()).toEqual({
+      args: [undefined, undefined, undefined],
+      i: 1
+    });
     expect(i).toBe(1);
-    var args = [{ foo: 'oof' }, { bar: 'rab' }, { baz: 'zab' }];
-    expect(memoizedFn.apply(undefined, args)).toEqual({ args: [{ foo: 'oof' }, { bar: 'rab' }, { baz: 'zab' }], i: 2 });
+    const args = [{
+      foo: 'oof'
+    }, {
+      bar: 'rab'
+    }, {
+      baz: 'zab'
+    }];
+    expect(memoizedFn(...args)).toEqual({
+      args: [{
+        foo: 'oof'
+      }, {
+        bar: 'rab'
+      }, {
+        baz: 'zab'
+      }],
+      i: 2
+    });
     expect(i).toBe(2);
-    expect(memoizedFn.apply(undefined, args)).toEqual({ args: [{ foo: 'oof' }, { bar: 'rab' }, { baz: 'zab' }], i: 2 });
+    expect(memoizedFn(...args)).toEqual({
+      args: [{
+        foo: 'oof'
+      }, {
+        bar: 'rab'
+      }, {
+        baz: 'zab'
+      }],
+      i: 2
+    });
     expect(i).toBe(2);
   });
+  it('does not memoize when non-identical arguments are passed', () => {
+    let i = 0;
 
-  it('does not memoize when non-identical arguments are passed', function () {
-    var i = 0;
     function fn(foo, bar, baz) {
@@ -99,19 +160,56 @@ i += 1;
         args: [foo, bar, baz],
-        i: i
+        i
       };
     }
-    var memoizedFn = memoize(fn);
+
+    const memoizedFn = memoize(fn);
     expect(i).toBe(0);
-    expect(memoizedFn()).toEqual({ args: [undefined, undefined, undefined], i: 1 });
+    expect(memoizedFn()).toEqual({
+      args: [undefined, undefined, undefined],
+      i: 1
+    });
     expect(i).toBe(1);
-    expect(memoizedFn()).toEqual({ args: [undefined, undefined, undefined], i: 1 });
+    expect(memoizedFn()).toEqual({
+      args: [undefined, undefined, undefined],
+      i: 1
+    });
     expect(i).toBe(1);
-    expect(memoizedFn({ foo: 'oof' }, { bar: 'rab' }, { baz: 'zab' })).toEqual({ args: [{ foo: 'oof' }, { bar: 'rab' }, { baz: 'zab' }], i: 2 });
+    expect(memoizedFn({
+      foo: 'oof'
+    }, {
+      bar: 'rab'
+    }, {
+      baz: 'zab'
+    })).toEqual({
+      args: [{
+        foo: 'oof'
+      }, {
+        bar: 'rab'
+      }, {
+        baz: 'zab'
+      }],
+      i: 2
+    });
     expect(i).toBe(2);
-    expect(memoizedFn({ foo: 'oof' }, { bar: 'rab' }, { baz: 'zab' })).toEqual({ args: [{ foo: 'oof' }, { bar: 'rab' }, { baz: 'zab' }], i: 3 });
+    expect(memoizedFn({
+      foo: 'oof'
+    }, {
+      bar: 'rab'
+    }, {
+      baz: 'zab'
+    })).toEqual({
+      args: [{
+        foo: 'oof'
+      }, {
+        bar: 'rab'
+      }, {
+        baz: 'zab'
+      }],
+      i: 3
+    });
     expect(i).toBe(3);
   });
+  it('memoizes by the first N arguments when the arity option is passed', () => {
+    let i = 0;
 
-  it('memoizes by the first N arguments when the arity option is passed', function () {
-    var i = 0;
     function fn(foo, bar, baz) {
@@ -121,12 +219,21 @@ i += 1;
         args: [foo, bar, baz],
-        i: i
+        i
       };
     }
-    var memoizedFn = memoize(fn, { arity: 2 });
-    expect(memoizedFn('foo', 'bar', 'baz')).toEqual({ args: ['foo', 'bar', 'baz'], i: 1 });
-    expect(memoizedFn('foo', 'bar', 'qux')).toEqual({ args: ['foo', 'bar', 'baz'], i: 1 });
+
+    const memoizedFn = memoize(fn, {
+      arity: 2
+    });
+    expect(memoizedFn('foo', 'bar', 'baz')).toEqual({
+      args: ['foo', 'bar', 'baz'],
+      i: 1
+    });
+    expect(memoizedFn('foo', 'bar', 'qux')).toEqual({
+      args: ['foo', 'bar', 'baz'],
+      i: 1
+    });
   });
+  it('memoizes the initial return value when and arity of 0 is passed', () => {
+    let i = 0;
 
-  it('memoizes the initial return value when and arity of 0 is passed', function () {
-    var i = 0;
     function fn(foo, bar, baz) {
@@ -136,101 +243,94 @@ i += 1;
         args: [foo, bar, baz],
-        i: i
+        i
       };
     }
-    var memoizedFn = memoize(fn, { arity: 0 });
-    expect(memoizedFn('foo', 'bar', 'baz')).toEqual({ args: ['foo', 'bar', 'baz'], i: 1 });
-    expect(memoizedFn('qux')).toEqual({ args: ['foo', 'bar', 'baz'], i: 1 });
+
+    const memoizedFn = memoize(fn, {
+      arity: 0
+    });
+    expect(memoizedFn('foo', 'bar', 'baz')).toEqual({
+      args: ['foo', 'bar', 'baz'],
+      i: 1
+    });
+    expect(memoizedFn('qux')).toEqual({
+      args: ['foo', 'bar', 'baz'],
+      i: 1
+    });
   });
+  it('memoizes node-style async functions', async () => {
+    let i = 0;
 
-  pit('memoizes node-style async functions', _asyncToGenerator(regeneratorRuntime.mark(function _callee() {
-    var i, fn, memoizedFn;
-    return regeneratorRuntime.wrap(function _callee$(_context) {
-      while (1) {
-        switch (_context.prev = _context.next) {
-          case 0:
-            fn = function fn(foo, bar, callback) {
-              i += 1;
-              setImmediate(function () {
-                callback(null, {
-                  args: [foo, bar],
-                  i: i
-                });
-              });
-            };
+    function fn(foo, bar, callback) {
+      i += 1;
+      setImmediate(() => {
+        callback(null, {
+          args: [foo, bar],
+          i
+        });
+      });
+    }
 
-            i = 0;
-            memoizedFn = memoize(fn, { async: true });
-            _context.next = 5;
-            return new Promise(function (resolve) {
-              memoizedFn('foo', 'bar', function (error, result) {
-                expect(result).toEqual({ args: ['foo', 'bar'], i: 1 });
-                resolve();
-              });
-            });
+    const memoizedFn = memoize(fn, {
+      async: true
+    });
+    await new Promise(resolve => {
+      memoizedFn('foo', 'bar', (error, result) => {
+        expect(result).toEqual({
+          args: ['foo', 'bar'],
+          i: 1
+        });
+        resolve();
+      });
+    });
+    await new Promise(resolve => {
+      let sync = true;
+      memoizedFn('foo', 'bar', (error, result) => {
+        expect(result).toEqual({
+          args: ['foo', 'bar'],
+          i: 1
+        });
+        expect(sync).toBe(false);
+        resolve();
+      });
+      sync = false;
+    });
+  });
+  it("calls the callback immediately when using async: 'immediate'", async () => {
+    let i = 0;
 
-          case 5:
-            _context.next = 7;
-            return new Promise(function (resolve) {
-              var sync = true;
-              memoizedFn('foo', 'bar', function (error, result) {
-                expect(result).toEqual({ args: ['foo', 'bar'], i: 1 });
-                expect(sync).toBe(false);
-                resolve();
-              });
-              sync = false;
-            });
+    function fn(foo, bar, callback) {
+      i += 1;
+      setImmediate(() => {
+        callback(null, {
+          args: [foo, bar],
+          i
+        });
+      });
+    }
 
-          case 7:
-          case 'end':
-            return _context.stop();
-        }
-      }
-    }, _callee, undefined);
-  })));
-
-  pit('calls the callback immediately when using async: \'immediate\'', _asyncToGenerator(regeneratorRuntime.mark(function _callee2() {
-    var i, fn, memoizedFn;
-    return regeneratorRuntime.wrap(function _callee2$(_context2) {
-      while (1) {
-        switch (_context2.prev = _context2.next) {
-          case 0:
-            fn = function fn(foo, bar, callback) {
-              i += 1;
-              setImmediate(function () {
-                callback(null, {
-                  args: [foo, bar],
-                  i: i
-                });
-              });
-            };
-
-            i = 0;
-            memoizedFn = memoize(fn, { async: 'immediate' });
-            _context2.next = 5;
-            return new Promise(function (resolve) {
-              memoizedFn('foo', 'bar', function (error, result) {
-                expect(result).toEqual({ args: ['foo', 'bar'], i: 1 });
-                resolve();
-              });
-            });
-
-          case 5:
-            _context2.next = 7;
-            return new Promise(function (resolve) {
-              var sync = true;
-              memoizedFn('foo', 'bar', function (error, result) {
-                expect(result).toEqual({ args: ['foo', 'bar'], i: 1 });
-                expect(sync).toBe(true);
-                resolve();
-              });
-              sync = false;
-            });
-
-          case 7:
-          case 'end':
-            return _context2.stop();
-        }
-      }
-    }, _callee2, undefined);
-  })));
+    const memoizedFn = memoize(fn, {
+      async: 'immediate'
+    });
+    await new Promise(resolve => {
+      memoizedFn('foo', 'bar', (error, result) => {
+        expect(result).toEqual({
+          args: ['foo', 'bar'],
+          i: 1
+        });
+        resolve();
+      });
+    });
+    await new Promise(resolve => {
+      let sync = true;
+      memoizedFn('foo', 'bar', (error, result) => {
+        expect(result).toEqual({
+          args: ['foo', 'bar'],
+          i: 1
+        });
+        expect(sync).toBe(true);
+        resolve();
+      });
+      sync = false;
+    });
+  });
 });

lib/index.js

@@ -1,2 +0,2 @@
-'use strict';
+"use strict";
 
@@ -7,9 +7,3 @@ Object.defineProperty(exports, "__esModule", {
 exports.default = memoize;
-
-function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }
-
-function _toArray(arr) { return Array.isArray(arr) ? arr : Array.from(arr); }
-
-var sentinel = Symbol('Cache key for `memoize` corresponding to the cached value for a complete set of arguments');
-
+const sentinel = Symbol('Cache key for `memoize` corresponding to the cached value for a complete set of arguments');
 /**
@@ -22,2 +16,3 @@ * Get a value from the given cache Map, accessing an inner Map for each value in `keys`.
  */
+
 function get(cache, keys) {
@@ -28,15 +23,11 @@ if (keys.length === 0) {
 
-  var _keys = _toArray(keys);
+  const [key, ...restKeys] = keys;
+  const nestedCache = cache.get(key);
 
-  var key = _keys[0];
-
-  var restKeys = _keys.slice(1);
-
-  var nestedCache = cache.get(key);
   if (!nestedCache) {
     return undefined;
   }
+
   return get(nestedCache, restKeys);
 }
-
 /**
@@ -50,2 +41,4 @@ * Set a value in the given cache Map, creating a new nested Map
  */
+
+
 function set(cache, keys, value) {
@@ -55,9 +48,5 @@ if (keys.length === 0) {
   } else {
-    var _keys2 = _toArray(keys);
+    const [key, ...restKeys] = keys;
+    let nestedCache = cache.get(key);
 
-    var key = _keys2[0];
-
-    var restKeys = _keys2.slice(1);
-
-    var nestedCache = cache.get(key);
     if (!nestedCache) {
@@ -67,21 +56,20 @@ nestedCache = new Map();
     }
+
     set(nestedCache, restKeys, value);
   }
+
   return value;
 }
 
-function memoizeAsync(fn, _ref) {
-  var arity = _ref.arity;
-  var immediate = _ref.immediate;
+function memoizeAsync(fn, {
+  arity,
+  immediate
+}) {
+  const cache = new Map();
+  return function memoized(...args) {
+    const fnArgs = args.slice(0, -1);
+    const callback = args[args.length - 1];
+    const cacheArgs = arity !== undefined ? fnArgs.slice(0, arity) : fnArgs;
+    const cached = get(cache, cacheArgs);
 
-  var cache = new Map();
-  return function memoized() {
-    for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
-      args[_key] = arguments[_key];
-    }
-
-    var fnArgs = args.slice(0, -1);
-    var callback = args[args.length - 1];
-    var cacheArgs = arity !== undefined ? fnArgs.slice(0, arity) : fnArgs;
-    var cached = get(cache, cacheArgs);
     if (cached) {
@@ -92,16 +80,16 @@ if (immediate) {
       }
-      setImmediate(function () {
-        return callback(null, cached);
-      });
+
+      setImmediate(() => callback(null, cached));
       return;
     }
-    fn.apply(undefined, _toConsumableArray(fnArgs).concat([function (error, result) {
+
+    fn(...fnArgs, (error, result) => {
       if (!error) {
         set(cache, cacheArgs, result);
       }
+
       callback(error, result);
-    }]));
+    });
   };
 }
-
 /**
@@ -125,20 +113,20 @@ * Memoize the given function by the identity of its arguments.
  */
-function memoize(fn) {
-  var _ref2 = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];
 
-  var arity = _ref2.arity;
-  var async = _ref2.async;
 
+function memoize(fn, {
+  arity,
+  async
+} = {}) {
   if (async) {
-    return memoizeAsync(fn, { arity: arity, immediate: async === 'immediate' });
+    return memoizeAsync(fn, {
+      arity,
+      immediate: async === 'immediate'
+    });
   }
-  var cache = new Map();
-  return function memoized() {
-    for (var _len2 = arguments.length, args = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
-      args[_key2] = arguments[_key2];
-    }
 
-    var cacheArgs = arity !== undefined ? args.slice(0, arity) : args;
-    return get(cache, cacheArgs) || set(cache, cacheArgs, fn.apply(undefined, args));
+  const cache = new Map();
+  return function memoized(...args) {
+    const cacheArgs = arity !== undefined ? args.slice(0, arity) : args;
+    return get(cache, cacheArgs) || set(cache, cacheArgs, fn(...args));
   };
 }

package.json

 {
   "name": "memoize-id",
-  "version": "0.2.0",
+  "version": "1.0.0",
   "description": "Memoize a function by the identity of its arguments, using ES2015 Map",
@@ -8,6 +8,7 @@ "main": "lib/index.js",
     "build": "babel src --out-dir lib",
+    "format:check": "prettier --check .",
+    "format:write": "prettier --write .",
     "jest": "jest",
-    "lint": "eslint .",
     "prepublish": "npm run build",
-    "test": "npm run lint && npm run jest"
+    "test": "npm run format:check && npm run jest"
   },
@@ -28,21 +29,14 @@ "repository": {
   "devDependencies": {
-    "babel-cli": "^6.5.1",
-    "babel-eslint": "^5.0.0",
-    "babel-jest": "^9.0.0",
-    "babel-plugin-transform-async-to-generator": "^6.7.0",
-    "babel-polyfill": "^6.6.1",
-    "babel-preset-es2015": "^6.5.0",
-    "eslint": "~2.2.0",
-    "eslint-config-airbnb": "^6.0.2",
-    "eslint-plugin-react": "^4.0.0",
-    "jest-cli": "^0.9.0"
+    "@babel/cli": "7.8.4",
+    "@babel/core": "7.9.6",
+    "@babel/preset-env": "7.9.6",
+    "babel-jest": "25.5.1",
+    "jest": "25.5.4",
+    "prettier": "2.0.5"
   },
   "jest": {
-    "testPathDirs": [
+    "roots": [
       "<rootDir>/src"
-    ],
-    "unmockedModulePathPatterns": [
-      "<rootDir>/node_modules"
     ]
   }
 }

README.md

@@ -1,5 +0,7 @@
-# memoize-id [![npm][npm-badge]][npm] [![Build Status][travis-badge]][travis]
-Memoize a function by the identity of its arguments, using [ES2015 Map][Map].
+# memoize-id [![npm][npm-badge]][npm]
 
+Memoize a function by the identity of its arguments, using [ES2015 Map][map].
+
 ### Installation
+
 ```shell
@@ -12,2 +14,3 @@ npm install memoize-id
 ### Usage
+
 ```js
@@ -51,4 +54,6 @@ import memoize from 'memoize-id';
 
-[Map]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map
-[Symbol]: https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Symbol
+[map]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map
+[symbol]: https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Symbol
+[greenkeeper]: https://greenkeeper.io/
+[greenkeeper-badge]: https://badges.greenkeeper.io/elliottsj/memoize-id.svg
 [npm]: https://www.npmjs.com/package/memoize-id
@@ -55,0 +60,0 @@ [npm-badge]: https://img.shields.io/npm/v/memoize-id.svg

src/__tests__/memoize-test.js

@@ -50,11 +50,26 @@ jest.dontMock('../index');
     expect(i).toBe(0);
-    expect(memoizedFn()).toEqual({ args: [undefined, undefined, undefined], i: 1 });
+    expect(memoizedFn()).toEqual({
+      args: [undefined, undefined, undefined],
+      i: 1,
+    });
     expect(i).toBe(1);
-    expect(memoizedFn()).toEqual({ args: [undefined, undefined, undefined], i: 1 });
+    expect(memoizedFn()).toEqual({
+      args: [undefined, undefined, undefined],
+      i: 1,
+    });
     expect(i).toBe(1);
-    expect(memoizedFn('foo', 'bar', 'baz')).toEqual({ args: ['foo', 'bar', 'baz'], i: 2 });
+    expect(memoizedFn('foo', 'bar', 'baz')).toEqual({
+      args: ['foo', 'bar', 'baz'],
+      i: 2,
+    });
     expect(i).toBe(2);
-    expect(memoizedFn('foo', 'bar', 'baz')).toEqual({ args: ['foo', 'bar', 'baz'], i: 2 });
+    expect(memoizedFn('foo', 'bar', 'baz')).toEqual({
+      args: ['foo', 'bar', 'baz'],
+      i: 2,
+    });
     expect(i).toBe(2);
-    expect(memoizedFn('foo', 'qux', 'baz')).toEqual({ args: ['foo', 'qux', 'baz'], i: 3 });
+    expect(memoizedFn('foo', 'qux', 'baz')).toEqual({
+      args: ['foo', 'qux', 'baz'],
+      i: 3,
+    });
     expect(i).toBe(3);
@@ -74,18 +89,22 @@ });
     expect(i).toBe(0);
-    expect(memoizedFn()).toEqual({ args: [undefined, undefined, undefined], i: 1 });
+    expect(memoizedFn()).toEqual({
+      args: [undefined, undefined, undefined],
+      i: 1,
+    });
     expect(i).toBe(1);
-    expect(memoizedFn()).toEqual({ args: [undefined, undefined, undefined], i: 1 });
+    expect(memoizedFn()).toEqual({
+      args: [undefined, undefined, undefined],
+      i: 1,
+    });
     expect(i).toBe(1);
     const args = [{ foo: 'oof' }, { bar: 'rab' }, { baz: 'zab' }];
-    expect(
-      memoizedFn(...args)
-    ).toEqual(
-      { args: [{ foo: 'oof' }, { bar: 'rab' }, { baz: 'zab' }], i: 2 }
-    );
+    expect(memoizedFn(...args)).toEqual({
+      args: [{ foo: 'oof' }, { bar: 'rab' }, { baz: 'zab' }],
+      i: 2,
+    });
     expect(i).toBe(2);
-    expect(
-      memoizedFn(...args)
-    ).toEqual(
-      { args: [{ foo: 'oof' }, { bar: 'rab' }, { baz: 'zab' }], i: 2 }
-    );
+    expect(memoizedFn(...args)).toEqual({
+      args: [{ foo: 'oof' }, { bar: 'rab' }, { baz: 'zab' }],
+      i: 2,
+    });
     expect(i).toBe(2);
@@ -105,17 +124,21 @@ });
     expect(i).toBe(0);
-    expect(memoizedFn()).toEqual({ args: [undefined, undefined, undefined], i: 1 });
+    expect(memoizedFn()).toEqual({
+      args: [undefined, undefined, undefined],
+      i: 1,
+    });
     expect(i).toBe(1);
-    expect(memoizedFn()).toEqual({ args: [undefined, undefined, undefined], i: 1 });
+    expect(memoizedFn()).toEqual({
+      args: [undefined, undefined, undefined],
+      i: 1,
+    });
     expect(i).toBe(1);
-    expect(
-      memoizedFn({ foo: 'oof' }, { bar: 'rab' }, { baz: 'zab' })
-    ).toEqual(
-      { args: [{ foo: 'oof' }, { bar: 'rab' }, { baz: 'zab' }], i: 2 }
-    );
+    expect(memoizedFn({ foo: 'oof' }, { bar: 'rab' }, { baz: 'zab' })).toEqual({
+      args: [{ foo: 'oof' }, { bar: 'rab' }, { baz: 'zab' }],
+      i: 2,
+    });
     expect(i).toBe(2);
-    expect(
-      memoizedFn({ foo: 'oof' }, { bar: 'rab' }, { baz: 'zab' })
-    ).toEqual(
-      { args: [{ foo: 'oof' }, { bar: 'rab' }, { baz: 'zab' }], i: 3 }
-    );
+    expect(memoizedFn({ foo: 'oof' }, { bar: 'rab' }, { baz: 'zab' })).toEqual({
+      args: [{ foo: 'oof' }, { bar: 'rab' }, { baz: 'zab' }],
+      i: 3,
+    });
     expect(i).toBe(3);
@@ -134,4 +157,10 @@ });
     const memoizedFn = memoize(fn, { arity: 2 });
-    expect(memoizedFn('foo', 'bar', 'baz')).toEqual({ args: ['foo', 'bar', 'baz'], i: 1 });
-    expect(memoizedFn('foo', 'bar', 'qux')).toEqual({ args: ['foo', 'bar', 'baz'], i: 1 });
+    expect(memoizedFn('foo', 'bar', 'baz')).toEqual({
+      args: ['foo', 'bar', 'baz'],
+      i: 1,
+    });
+    expect(memoizedFn('foo', 'bar', 'qux')).toEqual({
+      args: ['foo', 'bar', 'baz'],
+      i: 1,
+    });
   });
@@ -149,7 +178,10 @@
     const memoizedFn = memoize(fn, { arity: 0 });
-    expect(memoizedFn('foo', 'bar', 'baz')).toEqual({ args: ['foo', 'bar', 'baz'], i: 1 });
+    expect(memoizedFn('foo', 'bar', 'baz')).toEqual({
+      args: ['foo', 'bar', 'baz'],
+      i: 1,
+    });
     expect(memoizedFn('qux')).toEqual({ args: ['foo', 'bar', 'baz'], i: 1 });
   });
 
-  pit('memoizes node-style async functions', async () => {
+  it('memoizes node-style async functions', async () => {
     let i = 0;
@@ -183,3 +215,3 @@ function fn(foo, bar, callback) {
 
-  pit('calls the callback immediately when using async: \'immediate\'', async () => {
+  it("calls the callback immediately when using async: 'immediate'", async () => {
     let i = 0;
@@ -186,0 +218,0 @@ function fn(foo, bar, callback) {

Fixed alerts

Major refactor

Supply chain risk

Package has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.

Found 1 instance in 1 package

No v1

Quality

Package is not semver >=1. This means it is not stable and does not support ^ ranges.

Found 1 instance in 1 package

Improved metrics

Dev dependency count

6

decreased by-40%

Lines of code

737

increased by19.45%

Number of low quality alerts

0

decreased by-100%

Number of lines in readme file

61

increased by8.93%

Number of medium supply chain risk alerts

0

decreased by-100%

Worsened metrics

Total package byte prevSize

23641

decreased by-7.16%

No dependency changes