@chriscdn/memoize 1.0.5 → 1.0.6

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2024 Christopher Meyer
+Copyright (c) 2024-2025 Christopher Meyer
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -18,21 +18,22 @@ yarn add @chriscdn/memoize
 
 ## Usage
 
-The package comes with two functions: `Memoize` and `MemoizeAsync`.
+The package provides two functions: `Memoize` and `MemoizeAsync`.
 
 ```ts
 import { Memoize, MemoizeAsync } from "@chriscdn/memoize";
 ```
 
-The `Memoize` function can be used to memoize a _synchronous_ function. The `MemoizeAsync` function can be used to memoize an _asynchronous_ function. The cache is based [quick-lru](https://www.npmjs.com/package/quick-lru).
+- **`Memoize`** is used to memoize a _synchronous_ function.
+- **`MemoizeAsync`** is used to memoize an _asynchronous_ function.
 
-Each call to `Memoize` or `MemoizeAsync` will create a new cache instance.
+The cache is powered by [quick-lru](https://www.npmjs.com/package/quick-lru). Each call to `Memoize` or `MemoizeAsync` creates a new cache instance.
 
-The `MemoizeAsync` function prevents duplicate evaluations by ensuring multiple calls with an identical cache key is only processed once.
+The `MemoizeAsync` function prevents duplicate evaluations by ensuring that multiple calls with the same cache key are processed only once.
 
-By default, the cache key is generated by calling `JSON.stringify()` on the function arguments. This can be customized (see below).
+By default, the cache key is generated by calling `JSON.stringify()` on the function arguments. This behavior can be customized (see below).
 
-**Example (synchronous)**
+### Example (Synchronous)
 
 To memoize a function:
 
@@ -49,9 +50,15 @@ const result = add(5, 7);
 // 12
 ```
 
-**Example (asynchronous)**
+You can also define the function in a single line:
 
-The asynchronous case is similar:
+```ts
+const add = Memoize((x: number, y: number) => x + y);
+```
+
+### Example (Asynchronous)
+
+Memoizing an asynchronous function is similar:
 
 ```ts
 const _add = async (x: number, y: number) => x + y;
@@ -64,44 +71,47 @@ const result = await add(5, 7);
 
 ## Options
 
-The `Memoize` and `MemoizeAsync` functions accept an `Options` parameter to control the behaviour of the cache.
+Both `Memoize` and `MemoizeAsync` accept an `options` parameter to control the cache behavior:
 
 ```ts
 const add = MemoizeAsync(_add, options);
 ```
 
-The available options are as follows, with their defaults:
+Available options (with defaults):
 
 ```ts
 const options = {
-  // maximum number of items in the cache
+  // Maximum number of items in the cache
   maxSize: 1000,
 
-  // maximum number of milliseconds an item is to remain in the cache, undefined implies forever
+  // Maximum lifespan of an item in milliseconds; undefined means items never expire
   maxAge: undefined,
 
-  // a synchronous function for generating a cache key (must return a String)
+  // A synchronous function to generate cache keys (must return a string)
   resolver: (...args) => JSON.stringify(args),
 };
 ```
 
 ## Cache
 
-The underlying [quick-lru](https://www.npmjs.com/package/quick-lru) instance can be accessed with the `.cache` property on the memoized function.
+The underlying [quick-lru](https://www.npmjs.com/package/quick-lru) instance is accessible via the `.cache` property on the memoized function:
 
 ```ts
 const add = MemoizeAsync(_add);
 const result = await add(5, 7);
 
-console.log(addCachedAsync.cache.size === 1);
+console.log(add.cache.size === 1);
 // true
+
+// Clear the cache
+add.cache.clear();
 ```
 
 ## Class Methods
 
-Class methods can also be memoized, though this requires overriding the method within the constructor. When doing so, it's important to bind the method to the instance to ensure it maintains the correct context.
+Class methods can also be memoized, but this requires overriding the method within the constructor. Ensure you bind the method to the instance to maintain the correct context.
 
-Consider the following example, where the `add` method is memoized by reassigning it within the constructor after binding it to the current instance. This ensures the memoized version retains access to instance properties like `count` and keeps TypeScript happy by preserving the method's type signature.
+Here's an example where the `add` method is memoized by reassigning it within the constructor. This approach preserves access to instance properties (like `count`) and maintains the correct method signature in TypeScript:
 
 ```ts
 class AddClass {
@@ -118,10 +128,12 @@ class AddClass {
 }
 ```
 
-Keep in mind that each instance of a class will maintain its own separate cache.
+Each memoized method in each class instance maintains its own cache.
 
 ## Tests
 
+Run the tests using:
+
 ```bash
 yarn test
 ```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chriscdn/memoize",
-  "version": "1.0.5",
+  "version": "1.0.6",
   "description": "Memoize a synchronous or asynchronous function.",
   "repository": "https://github.com/chriscdn/memoize",
   "author": "Christopher Meyer <chris@schwiiz.org>",