npm - @common.js/p-memoize - Versions diffs - 7.1.1 → 8.0.1 - Mend

@common.js/p-memoize 7.1.1 → 8.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (4) hide show

package/README.md CHANGED Viewed

@@ -2,4 +2,4 @@
 The [p-memoize](https://www.npmjs.com/package/p-memoize) package exported as CommonJS modules.
-Exported from [p-memoize@7.1.1](https://www.npmjs.com/package/p-memoize/v/7.1.1) using https://github.com/etienne-martin/common.js.
+Exported from [p-memoize@8.0.0](https://www.npmjs.com/package/p-memoize/v/8.0.0) using https://github.com/etienne-martin/common.js.

package/dist/index.d.ts CHANGED Viewed

@@ -1,15 +1,22 @@
 import type { AsyncReturnType } from 'type-fest';
-export declare type AnyAsyncFunction = (...arguments_: readonly any[]) => Promise<unknown | void>;
-export declare type CacheStorage<KeyType, ValueType> = {
+export type AnyAsyncFunction = (...arguments_: readonly any[]) => Promise<unknown | void>;
+export type CacheStorage<KeyType, ValueType> = {
     has: (key: KeyType) => Promise<boolean> | boolean;
     get: (key: KeyType) => Promise<ValueType | undefined> | ValueType | undefined;
     set: (key: KeyType, value: ValueType) => Promise<unknown> | unknown;
     delete: (key: KeyType) => unknown;
     clear?: () => unknown;
 };
-export declare type Options<FunctionToMemoize extends AnyAsyncFunction, CacheKeyType> = {
+/**
+Controls whether a fulfilled value should be written to the cache.
+*/
+export type ShouldCache<KeyType, ValueType, ArgumentsList extends readonly unknown[] = readonly unknown[]> = (value: ValueType, context: {
+    key: KeyType;
+    argumentsList: ArgumentsList;
+}) => boolean | Promise<boolean>;
+export type Options<FunctionToMemoize extends AnyAsyncFunction, CacheKeyType> = {
     /**
-    Determines the cache key for storing the result based on the function arguments. By default, __only the first argument is considered__ and it only works with [primitives](https://developer.mozilla.org/en-US/docs/Glossary/Primitive).
+    Determines the cache key for storing the result based on the function arguments. By default, __only the first argument is considered__ and it only works with [primitives](https://developer.mozilla.org/docs/Glossary/Primitive).
     A `cacheKey` function can return any type supported by `Map` (or whatever structure you use in the `cache` option).
@@ -41,6 +48,33 @@ export declare type Options<FunctionToMemoize extends AnyAsyncFunction, CacheKey
     @example new WeakMap()
     */
     readonly cache?: CacheStorage<CacheKeyType, AsyncReturnType<FunctionToMemoize>> | false;
+    /**
+    Controls whether a fulfilled value should be written to the cache.
+    It runs after the function fulfills and before `cache.set`.
+    - Omit to keep current behavior (always write).
+    - Return `false` to skip writing to the cache (in-flight de-duplication is still cleared).
+    - Throw or reject to propagate the error and skip caching.
+    @example
+    ```
+    import pMemoize from 'p-memoize';
+    // Only cache defined values
+    const getMaybe = pMemoize(async key => db.get(key), {
+        shouldCache: value => value !== undefined,
+    });
+    // Only cache non-empty arrays
+    const search = pMemoize(async query => fetchResults(query), {
+        shouldCache: value => Array.isArray(value) && value.length > 0,
+    });
+    ```
+    Note: This only affects writes; reads from the cache are unchanged.
+    */
+    readonly shouldCache?: ShouldCache<CacheKeyType, AsyncReturnType<FunctionToMemoize>, Parameters<FunctionToMemoize>>;
 };
 /**
 [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.
@@ -66,13 +100,14 @@ await delay(2000);
 await memoizedGot('https://sindresorhus.com');
 ```
 */
-export default function pMemoize<FunctionToMemoize extends AnyAsyncFunction, CacheKeyType>(fn: FunctionToMemoize, { cacheKey, cache, }?: Options<FunctionToMemoize, CacheKeyType>): FunctionToMemoize;
+export default function pMemoize<FunctionToMemoize extends AnyAsyncFunction, CacheKeyType = Parameters<FunctionToMemoize>[0], OptionsType = Options<FunctionToMemoize, CacheKeyType>>(fn: FunctionToMemoize, options?: OptionsType & Options<FunctionToMemoize, CacheKeyType>): FunctionToMemoize;
 /**
-- Only class methods and getters/setters can be memoized, not regular functions (they aren't part of the proposal);
-- Only [TypeScript’s decorators](https://www.typescriptlang.org/docs/handbook/decorators.html#parameter-decorators) are supported, not [Babel’s](https://babeljs.io/docs/en/babel-plugin-proposal-decorators), which use a different version of the proposal;
-- Being an experimental feature, they need to be enabled with `--experimentalDecorators`; follow TypeScript’s docs.
+- Only class methods are supported; regular functions are not part of the decorators proposals.
+- Uses the new ECMAScript decorators (TypeScript 5.0+). Legacy `experimentalDecorators` are not supported.
+- Babel’s legacy decorators are not supported.
+- Private methods are not supported.
-@returns A [decorator](https://github.com/tc39/proposal-decorators) to memoize class methods or static class methods.
+@returns A decorator to memoize class methods or static class methods.
 @example
 ```
@@ -97,7 +132,7 @@ class ExampleWithOptions {
 }
 ```
 */
-export declare function pMemoizeDecorator<FunctionToMemoize extends AnyAsyncFunction, CacheKeyType>(options?: Options<FunctionToMemoize, CacheKeyType>): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
+export declare function pMemoizeDecorator<FunctionToMemoize extends AnyAsyncFunction = AnyAsyncFunction, CacheKeyType = Parameters<FunctionToMemoize>[0]>(options?: Options<NoInfer<FunctionToMemoize>, NoInfer<CacheKeyType>>): <This, Value extends FunctionToMemoize>(value: Value, context: ClassMethodDecoratorContext<This, Value>) => void;
 /**
 Clear all cached data of a memoized function.

package/dist/index.js CHANGED Viewed

@@ -42,7 +42,7 @@ await memoizedGot('https://sindresorhus.com');
         return pMemoizeClear;
     }
 });
-var _mimicFn = /*#__PURE__*/ _interopRequireDefault(require("mimic-fn"));
+var _mimicFunction = /*#__PURE__*/ _interopRequireDefault(require("mimic-function"));
 function _arrayLikeToArray(arr, len) {
     if (len == null || len > arr.length) len = arr.length;
     for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
@@ -219,11 +219,12 @@ var __generator = (void 0) && (void 0).__generator || function(thisArg, body) {
     }
 };
 var cacheStore = new WeakMap();
-function pMemoize(fn) {
-    var ref = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}, _cacheKey = ref.cacheKey, cacheKey = _cacheKey === void 0 ? function(param) {
+function pMemoize(fn, options) {
+    var defaultCacheKey = function(param) {
         var _param = _slicedToArray(param, 1), firstArgument = _param[0];
         return firstArgument;
-    } : _cacheKey, _cache = ref.cache, cache = _cache === void 0 ? new Map() : _cache;
+    };
+    var ref = options !== null && options !== void 0 ? options : {}, _cacheKey = ref.cacheKey, cacheKey = _cacheKey === void 0 ? defaultCacheKey : _cacheKey, _cache = ref.cache, cache = _cache === void 0 ? new Map() : _cache;
     // Promise objects can't be serialized so we keep track of them internally and only provide their resolved values to `cache`
     // `Promise<AsyncReturnType<FunctionToMemoize>>` is used instead of `ReturnType<FunctionToMemoize>` because promise properties are not kept
     var promiseCache = new Map();
@@ -237,15 +238,15 @@ function pMemoize(fn) {
         }
         var _this = this;
         var promise = _asyncToGenerator(function() {
-            var _tmp, promise, result;
+            var _tmp, promise, result, allow, _tmp1;
             return __generator(this, function(_state) {
                 switch(_state.label){
                     case 0:
                         _state.trys.push([
                             0,
                             ,
-                            11,
-                            12
+                            14,
+                            15
                         ]);
                         _tmp = cache;
                         if (!_tmp) return [
@@ -287,7 +288,7 @@ function pMemoize(fn) {
                             6,
                             ,
                             7,
-                            10
+                            13
                         ]);
                         return [
                             2,
@@ -295,31 +296,57 @@ function pMemoize(fn) {
                         ];
                     case 7:
                         if (!cache) return [
+                            3,
+                            12
+                        ];
+                        if (!(options === null || options === void 0 ? void 0 : options.shouldCache)) return [
                             3,
                             9
                         ];
                         return [
                             4,
-                            cache.set(key, result)
+                            options.shouldCache(result, {
+                                key: key,
+                                argumentsList: arguments_
+                            })
                         ];
                     case 8:
-                        _state.sent();
-                        _state.label = 9;
-                    case 9:
+                        _tmp1 = _state.sent();
                         return [
-                            7
+                            3,
+                            10
                         ];
+                    case 9:
+                        _tmp1 = true;
+                        _state.label = 10;
                     case 10:
-                        return [
+                        allow = _tmp1;
+                        if (!allow) return [
                             3,
                             12
                         ];
+                        return [
+                            4,
+                            cache.set(key, result)
+                        ];
                     case 11:
+                        _state.sent();
+                        _state.label = 12;
+                    case 12:
+                        return [
+                            7
+                        ];
+                    case 13:
+                        return [
+                            3,
+                            15
+                        ];
+                    case 14:
                         promiseCache.delete(key);
                         return [
                             7
                         ];
-                    case 12:
+                    case 15:
                         return [
                             2
                         ];
@@ -329,7 +356,7 @@ function pMemoize(fn) {
         promiseCache.set(key, promise);
         return promise;
     };
-    (0, _mimicFn.default)(memoized, fn, {
+    (0, _mimicFunction.default)(memoized, fn, {
         ignoreNonConfigurable: true
     });
     cacheStore.set(memoized, cache);
@@ -337,22 +364,22 @@ function pMemoize(fn) {
 }
 function pMemoizeDecorator() {
     var options = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
-    var instanceMap = new WeakMap();
-    return function(target, propertyKey, descriptor) {
-        var input = target[propertyKey]; // eslint-disable-line @typescript-eslint/no-unsafe-assignment
-        if (typeof input !== "function") {
-            throw new TypeError("The decorated value must be a function");
+    return function(value, context) {
+        if (context.kind !== "method") {
+            throw new TypeError("pMemoizeDecorator can only decorate methods");
         }
-        delete descriptor.value;
-        delete descriptor.writable;
-        descriptor.get = function() {
-            if (!instanceMap.has(this)) {
-                var value = pMemoize(input, options);
-                instanceMap.set(this, value);
-                return value;
-            }
-            return instanceMap.get(this);
-        };
+        if (context.private) {
+            throw new TypeError("pMemoizeDecorator cannot decorate private methods");
+        }
+        context.addInitializer(function() {
+            var memoizedMethod = pMemoize(value, options);
+            Object.defineProperty(this, context.name, {
+                configurable: true,
+                writable: true,
+                enumerable: false,
+                value: memoizedMethod
+            });
+        });
     };
 }
 function pMemoizeClear(fn) {

package/package.json CHANGED Viewed

@@ -1,14 +1,19 @@
 {
   "name": "@common.js/p-memoize",
-  "version": "7.1.1",
+  "version": "8.0.1",
   "description": "p-memoize package exported as CommonJS modules",
   "license": "MIT",
   "repository": "etienne-martin/common.js",
   "funding": "https://github.com/sindresorhus/p-memoize?sponsor=1",
   "type": "commonjs",
   "types": "./dist/index.d.ts",
+  "exports": {
+    "types": "./dist/index.d.ts",
+    "default": "./dist/index.js"
+  },
+  "sideEffects": false,
   "engines": {
-    "node": ">=14.16"
+    "node": ">=20"
   },
   "scripts": {
     "test": "xo && ava && npm run build && tsd",
@@ -18,28 +23,31 @@
     "dist"
   ],
   "dependencies": {
-    "@common.js/mimic-fn": "^4.0.0",
-    "type-fest": "^3.0.0"
+    "mimic-function": "npm:@common.js/mimic-function@5.0.2",
+    "type-fest": "^4.41.0"
   },
   "devDependencies": {
-    "@sindresorhus/tsconfig": "^3.0.1",
-    "@types/serialize-javascript": "^5.0.2",
-    "ava": "^4.3.3",
-    "del-cli": "^5.0.0",
-    "delay": "^5.0.0",
-    "p-defer": "^4.0.0",
-    "p-state": "^1.0.0",
-    "serialize-javascript": "^6.0.0",
-    "ts-node": "^10.9.1",
-    "tsd": "^0.24.1",
-    "xo": "^0.52.4"
+    "@sindresorhus/tsconfig": "^8.0.1",
+    "@types/serialize-javascript": "^5.0.4",
+    "ava": "^6.4.1",
+    "del-cli": "^6.0.0",
+    "delay": "^6.0.0",
+    "p-defer": "^4.0.1",
+    "p-state": "^2.0.1",
+    "serialize-javascript": "^6.0.2",
+    "tsd": "^0.33.0",
+    "tsimp": "^2.0.12",
+    "xo": "^1.2.1"
   },
   "ava": {
+    "environmentVariables": {
+      "TSIMP_DIAG": "ignore"
+    },
     "extensions": {
       "ts": "module"
     },
     "nodeArguments": [
-      "--loader=ts-node/esm"
+      "--import=tsimp/import"
     ]
   },
   "xo": {
@@ -48,5 +56,13 @@
     }
   },
   "homepage": "https://github.com/etienne-martin/common.js#readme",
+  "commonjs": {
+    "source": {
+      "name": "p-memoize",
+      "version": "8.0.0"
+    },
+    "transformRevision": 1,
+    "buildKey": "3d7fee255a1f5ce8a0652ddb6d3fa472cda05272baa8ee4e5985b8b4d3ee22ab"
+  },
   "main": "./dist/index.js"
 }