{"_id":"@cjser/memoize__v10_2_0","name":"@cjser/memoize__v10_2_0","dist-tags":{"latest":"10.2.0-cjser.2"},"versions":{"10.2.0-cjser.2":{"name":"@cjser/memoize__v10_2_0","version":"10.2.0-cjser.2","description":"Memoize functions - An optimization used to speed up consecutive function calls by caching the result of calls with identical input","license":"MIT","repository":{"type":"git","url":"https://code.moenext.com/3rdeye/cjser.git"},"funding":"https://github.com/sindresorhus/memoize?sponsor=1","author":{"name":"Sindre Sorhus","email":"sindresorhus@gmail.com","url":"https://sindresorhus.com"},"type":"module","exports":{"types":"./distribution/index.d.ts","require":"./dist-cjser/index.cjs","default":"./distribution/index.js"},"sideEffects":false,"engines":{"node":">=18"},"scripts":{"test":"xo && ava && npm run build && tsd --typings distribution/index.d.ts","build":"del-cli distribution && tsc"},"keywords":["memoize","function","mem","memoization","cache","caching","optimize","performance","ttl","expire","promise"],"dependencies":{"@cjser/mimic-function":"5.0.1-cjser.2"},"devDependencies":{"@sindresorhus/tsconfig":"^6.0.0","@types/serialize-javascript":"^5.0.4","ava":"^6.1.3","del-cli":"^5.1.0","delay":"^6.0.0","serialize-javascript":"^6.0.2","ts-node":"^10.9.2","tsd":"^0.31.1","xo":"^0.59.3"},"ava":{"timeout":"1m","extensions":{"ts":"module"},"nodeArguments":["--loader=ts-node/esm"],"workerThreads":false},"xo":{"rules":{"@typescript-eslint/no-unsafe-return":"off"}},"types":"./distribution/index.d.ts","main":"./dist-cjser/index.cjs","cjser":{"sourceVersion":"10.2.0","cjserVersion":2,"original":{"name":"memoize","version":"10.2.0","exports":{"types":"./distribution/index.d.ts","default":"./distribution/index.js"},"repository":"sindresorhus/memoize","dependencies":{"mimic-function":"^5.0.1"},"files":["distribution"],"scripts":{"test":"xo && ava && npm run build && tsd --typings distribution/index.d.ts","build":"del-cli distribution && tsc","prepack":"npm run build"}}},"_id":"@cjser/memoize__v10_2_0@10.2.0-cjser.2","gitHead":"a4bef54d7d22d3d9a6b84528457938d84cd65fe7","_nodeVersion":"20.14.0","_npmVersion":"10.7.0","dist":{"integrity":"sha512-Mo2mUzlxXvpXXnlTTk86Vz0heNiPkB6R68HXoKJQsTAS9Q8Ha31p7rfC8810YLsZBLZ0Dbh5d3YqF8gH9UGDDA==","shasum":"e180c14e9ebd4fa73d75b38d0c34c095ae53f6f7","tarball":"https://registry.npmjs.org/@cjser/memoize__v10_2_0/-/memoize__v10_2_0-10.2.0-cjser.2.tgz","fileCount":6,"unpackedSize":30121,"signatures":[{"keyid":"SHA256:DhQ8wR5APBvFHLF/+Tc+AYvPOdTpcIDqOhxsBHRwC7U","sig":"MEUCICzHP26QYrwu6LvJ63qFAkSvu43WI82/Am0Uv4bGxezhAiEA/LETCpt6YXKMxMVyDBgKy/pAQQv36B6SnpZHOiGq2sE="}]},"_npmUser":{"name":"nanahira","email":"nanahira@momobako.com"},"directories":{},"maintainers":[{"name":"nanahira","email":"nanahira@momobako.com"}],"_npmOperationalInternal":{"host":"s3://npm-registry-packages-npm-production","tmp":"tmp/memoize__v10_2_0_10.2.0-cjser.2_1778159042443_0.7288710496319906"},"_hasShrinkwrap":false}},"time":{"created":"2026-05-07T13:04:02.380Z","10.2.0-cjser.2":"2026-05-07T13:04:02.583Z","modified":"2026-05-07T13:04:02.831Z"},"maintainers":[{"name":"nanahira","email":"nanahira@momobako.com"}],"description":"Memoize functions - An optimization used to speed up consecutive function calls by caching the result of calls with identical input","keywords":["memoize","function","mem","memoization","cache","caching","optimize","performance","ttl","expire","promise"],"repository":{"type":"git","url":"https://code.moenext.com/3rdeye/cjser.git"},"author":{"name":"Sindre Sorhus","email":"sindresorhus@gmail.com","url":"https://sindresorhus.com"},"license":"MIT","readme":"# memoize\n\n> [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\n\nMemory is automatically released when an item expires or the cache is cleared.\n\n<!-- Please keep this section in sync with https://github.com/sindresorhus/p-memoize/blob/main/readme.md -->\n\nBy default, **only the memoized function's first argument is considered** via strict equality comparison. If you need to cache multiple arguments or cache `object`s *by value*, have a look at alternative [caching strategies](#caching-strategy) below.\n\nIf you want to memoize Promise-returning functions (like `async` functions), you might be better served by [p-memoize](https://github.com/sindresorhus/p-memoize).\n\n## Install\n\n```sh\nnpm install memoize\n```\n\n## Usage\n\n```js\nimport memoize from 'memoize';\n\nlet index = 0;\nconst counter = () => ++index;\nconst memoized = memoize(counter);\n\nmemoized('foo');\n//=> 1\n\n// Cached as it's the same argument\nmemoized('foo');\n//=> 1\n\n// Not cached anymore as the argument changed\nmemoized('bar');\n//=> 2\n\nmemoized('bar');\n//=> 2\n\n// Only the first argument is considered by default\nmemoized('bar', 'foo');\n//=> 2\n```\n\n##### Works well with Promise-returning functions\n\nBut you might want to use [p-memoize](https://github.com/sindresorhus/p-memoize) for more Promise-specific behaviors.\n\n```js\nimport memoize from 'memoize';\n\nlet index = 0;\nconst counter = async () => ++index;\nconst memoized = memoize(counter);\n\nconsole.log(await memoized());\n//=> 1\n\n// The return value didn't increase as it's cached\nconsole.log(await memoized());\n//=> 1\n```\n\n```js\nimport memoize from 'memoize';\nimport got from 'got';\nimport delay from 'delay';\n\nconst memoizedGot = memoize(got, {maxAge: 1000});\n\nawait memoizedGot('https://sindresorhus.com');\n\n// This call is cached\nawait memoizedGot('https://sindresorhus.com');\n\nawait delay(2000);\n\n// This call is not cached as the cache has expired\nawait memoizedGot('https://sindresorhus.com');\n```\n\n### Caching strategy\n\nBy default, only the first argument is compared via exact equality (`===`) to determine whether a call is identical.\n\n```js\nimport memoize from 'memoize';\n\nconst pow = memoize((a, b) => Math.pow(a, b));\n\npow(2, 2); // => 4, stored in cache with the key 2 (number)\npow(2, 3); // => 4, retrieved from cache at key 2 (number), it's wrong\n```\n\nYou will have to use the `cache` and `cacheKey` options appropriate to your function. In this specific case, the following could work:\n\n```js\nimport memoize from 'memoize';\n\nconst pow = memoize((a, b) => Math.pow(a, b), {\n  cacheKey: arguments_ => arguments_.join(',')\n});\n\npow(2, 2); // => 4, stored in cache with the key '2,2' (both arguments as one string)\npow(2, 3); // => 8, stored in cache with the key '2,3'\n```\n\nMore advanced examples follow.\n\n#### Example: Options-like argument\n\nIf your function accepts an object, it won't be memoized out of the box:\n\n```js\nimport memoize from 'memoize';\n\nconst heavyMemoizedOperation = memoize(heavyOperation);\n\nheavyMemoizedOperation({full: true}); // Stored in cache with the object as key\nheavyMemoizedOperation({full: true}); // Stored in cache with the object as key, again\n// The objects appear the same, but in JavaScript, they're different objects\n```\n\nYou might want to serialize or hash them, for example using `JSON.stringify` or something like [serialize-javascript](https://github.com/yahoo/serialize-javascript), which can also serialize `RegExp`, `Date` and so on.\n\n```js\nimport memoize from 'memoize';\n\nconst heavyMemoizedOperation = memoize(heavyOperation, {cacheKey: JSON.stringify});\n\nheavyMemoizedOperation({full: true}); // Stored in cache with the key '[{\"full\":true}]' (string)\nheavyMemoizedOperation({full: true}); // Retrieved from cache\n```\n\nThe same solution also works if it accepts multiple serializable objects:\n\n```js\nimport memoize from 'memoize';\n\nconst heavyMemoizedOperation = memoize(heavyOperation, {cacheKey: JSON.stringify});\n\nheavyMemoizedOperation('hello', {full: true}); // Stored in cache with the key '[\"hello\",{\"full\":true}]' (string)\nheavyMemoizedOperation('hello', {full: true}); // Retrieved from cache\n```\n\n#### Example: Multiple non-serializable arguments\n\nIf your function accepts multiple arguments that aren't supported by `JSON.stringify` (e.g. DOM elements and functions), you can instead extend the initial exact equality (`===`) to work on multiple arguments using [`many-keys-map`](https://github.com/fregante/many-keys-map):\n\n```js\nimport memoize from 'memoize';\nimport ManyKeysMap from 'many-keys-map';\n\nconst addListener = (emitter, eventName, listener) => emitter.on(eventName, listener);\n\nconst addOneListener = memoize(addListener, {\n\tcacheKey: arguments_ => arguments_, // Use *all* the arguments as key\n\tcache: new ManyKeysMap() // Correctly handles all the arguments for exact equality\n});\n\naddOneListener(header, 'click', console.log); // `addListener` is run, and it's cached with the `arguments` array as key\naddOneListener(header, 'click', console.log); // `addListener` is not run again because the arguments are the same\naddOneListener(mainContent, 'load', console.log); // `addListener` is run, and it's cached with the `arguments` array as key\n```\n\nBetter yet, if your function’s arguments are compatible with `WeakMap`, you should use [`deep-weak-map`](https://github.com/futpib/deep-weak-map) instead of `many-keys-map`. This will help avoid memory leaks.\n\n## API\n\n### memoize(fn, options?)\n\n#### fn\n\nType: `Function`\n\nThe function to be memoized.\n\n#### options\n\nType: `object`\n\n##### maxAge\n\nType: `number` | `Function`\\\nDefault: `Infinity`\\\nExample: `arguments_ => arguments_ < new Date() ? Infinity : 60_000`\n\nMilliseconds until the cache entry expires.\n\nIf a function is provided, it receives the arguments and must return the max age.\n\n- `0` or negative values: Do not cache the result\n- `Infinity`: Cache indefinitely (no expiration)\n- Positive finite number: Cache for the specified milliseconds\n\n##### cacheKey\n\nType: `Function`\\\nDefault: `arguments_ => arguments_[0]`\\\nExample: `arguments_ => JSON.stringify(arguments_)`\n\nDetermines the cache key for storing the result based on the function arguments. By default, **only the first argument is considered**.\n\nA `cacheKey` function can return any type supported by `Map` (or whatever structure you use in the `cache` option).\n\nRefer to the [caching strategies](#caching-strategy) section for more information.\n\n##### cache\n\nType: `object`\\\nDefault: `new Map()`\n\nUse 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.\n\nRefer to the [caching strategies](#caching-strategy) section for more information.\n\n### memoizeDecorator(options)\n\nReturns a [decorator](https://github.com/tc39/proposal-decorators) to memoize class methods or static class methods.\n\nNotes:\n\n- Only class methods and getters/setters can be memoized, not regular functions (they aren't part of the proposal);\n- 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;\n- Being an experimental feature, they need to be enabled with `--experimentalDecorators`; follow TypeScript’s docs.\n\n#### options\n\nType: `object`\n\nSame as options for `memoize()`.\n\n```ts\nimport {memoizeDecorator} from 'memoize';\n\nclass Example {\n\tindex = 0\n\n\t@memoizeDecorator()\n\tcounter() {\n\t\treturn ++this.index;\n\t}\n}\n\nclass ExampleWithOptions {\n\tindex = 0\n\n\t@memoizeDecorator({maxAge: 1000})\n\tcounter() {\n\t\treturn ++this.index;\n\t}\n}\n```\n\n### memoizeClear(fn)\n\nClear all cached data of a memoized function.\n\n#### fn\n\nType: `Function`\n\nThe memoized function.\n\n### memoizeIsCached(fn, ...arguments)\n\nCheck if a specific set of arguments is cached for a memoized function.\n\nReturns `true` if the arguments are cached and not expired, `false` otherwise.\n\nUses the same argument processing as the memoized function, including any custom `cacheKey` function.\n\n```js\nimport memoize, {memoizeIsCached} from 'memoize';\n\nconst expensive = memoize((a, b) => a + b, {cacheKey: JSON.stringify});\nexpensive(1, 2);\n\nmemoizeIsCached(expensive, 1, 2);\n//=> true\n\nmemoizeIsCached(expensive, 3, 4);\n//=> false\n```\n\n#### fn\n\nType: `Function`\n\nThe memoized function.\n\n#### arguments\n\nThe arguments to check.\n\n## Tips\n\n### Cache statistics\n\nIf you want to know how many times your cache had a hit or a miss, you can make use of [stats-map](https://github.com/SamVerschueren/stats-map) as a replacement for the default cache.\n\n#### Example\n\n```js\nimport memoize from 'memoize';\nimport StatsMap from 'stats-map';\nimport got from 'got';\n\nconst cache = new StatsMap();\nconst memoizedGot = memoize(got, {cache});\n\nawait memoizedGot('https://sindresorhus.com');\nawait memoizedGot('https://sindresorhus.com');\nawait memoizedGot('https://sindresorhus.com');\n\nconsole.log(cache.stats);\n//=> {hits: 2, misses: 1}\n```\n\n## Related\n\n- [p-memoize](https://github.com/sindresorhus/p-memoize) - Memoize promise-returning & async functions\n\n## cjser\n\nThis package is a CommonJS-compatible build generated by cjser for projects that still need `require()` support. The source version matches the original npm package version, with a cjser prerelease suffix for this generated build.\nOriginal repository: https://github.com/sindresorhus/memoize\n","readmeFilename":"readme.md","_rev":"1-a4aefeddc28eda75363050cfc5e2497e"}