Fix caching bug with multiple instances

.gitignore

@@ -2,3 +2,4 @@
 /.idea
 /test/test.js
 coverage/
+/demo/demo.js

dist/memoize.d.ts

@@ -1,5 +1,5 @@
 /**!
- @preserve memoize-decorator 1.6.0
+ @preserve memoize-decorator 1.7.0
  @copyright 2023 Edwin Martin
  @license MIT
  */

package.json

@@ -1,6 +1,6 @@
 {
 	"name": "memoize-cache-decorator",
-	"version": "1.6.0",
+	"version": "1.7.0",
 	"description": "Cache the result of a method or getter for better performance. Supports timeout and clearing of the cache.",
 	"type": "module",
 	"license": "MIT",

src/memoize.ts

@@ -1,12 +1,14 @@
 /**!
- @preserve memoize-decorator 1.6.0
+ @preserve memoize-decorator 1.7.0
  @copyright 2023 Edwin Martin
  @license MIT
  */
 
 import stringify from "json-stringify-safe";
 
-const cacheMap = new Map();
+const cacheMap = new Map<(...args: any) => any, Map<string, CacheObject>>();
+const idPropertySymbol = Symbol();
+let uniqueObjectId = 1;
 
 export interface Config {
 	resolver?: (...args: any[]) => string | number;
@@ -27,37 +29,47 @@ export function memoize(config: Config = {}) {
 		const prop = propertyDescriptor.value ? "value" : "get";
 
 		const originalFunction = propertyDescriptor[prop];
-		const map: Map<string | number, CacheObject> = new Map();
+		const functionCacheMap = new Map<string, CacheObject>();
+
+		propertyDescriptor[prop] = function (
+			this: { [id: symbol]: number },
+			...args: any[]
+		) {
+			let objectId = this[idPropertySymbol];
+			if (!objectId) {
+				objectId = ++uniqueObjectId;
+				this[idPropertySymbol] = objectId;
+			}
 
-		propertyDescriptor[prop] = function (...args: any[]) {
 			const key = config.resolver
 				? config.resolver.apply(this, args)
 				: stringify(args);
+			const cacheKey = `${objectId}:${key}`;
 
-			if (map.has(key)) {
-				const { result, timeout } = map.get(key)!;
+			if (functionCacheMap.has(cacheKey)) {
+				const { result, timeout } = functionCacheMap.get(cacheKey)!;
 				if (!config.ttl || timeout > Date.now()) {
 					return result;
 				}
 			}
 			const newResult = originalFunction.apply(this, args);
-			map.set(key, {
+			functionCacheMap.set(cacheKey, {
 				result: newResult,
 				timeout: config.ttl ? Date.now() + config.ttl : Infinity,
 			});
 			return newResult;
 		};
 
-		cacheMap.set(propertyDescriptor[prop], map);
+		cacheMap.set(propertyDescriptor[prop], functionCacheMap);
 
 		return propertyDescriptor;
 	};
 }
 
 export function clear(fn: (...args: any) => any) {
-	const map = cacheMap.get(fn);
+	const functionCacheMap = cacheMap.get(fn);
 
-	if (map) {
-		map.clear();
+	if (functionCacheMap) {
+		functionCacheMap.clear();
 	}
 }

test/test.ts

@@ -98,7 +98,6 @@ it("Test resolver", () => {
 });
 
 it("Test ttl", async () => {
-	const example = new Example();
 	expect(example.expiring40()).toEqual("a=10");
 	expect(example.expiring60()).toEqual("a=10");
 	example.a++;
@@ -123,8 +122,22 @@ it("Test ttl", async () => {
 	expect(example.expiring60()).toEqual("a=15");
 });
 
+it("Test ttl with two instances", async () => {
+	const example2 = new Example();
+	expect(example.expiring40()).toEqual("a=10");
+	example.a++;
+	example2.a++;
+	await new Promise((resolve) => setTimeout(resolve, 30));
+	expect(example.expiring40()).toEqual("a=10");
+	expect(example2.expiring40()).toEqual("a=11");
+	example.a++;
+	example2.a++;
+	await new Promise((resolve) => setTimeout(resolve, 20));
+	expect(example.expiring40()).toEqual("a=12");
+	expect(example2.expiring40()).toEqual("a=11");
+});
+
 it("Test ttl with args", async () => {
-	const example = new Example();
 	expect(example.expiringArg("a")).toEqual("arg=10-a");
 	example.a++;
 	await new Promise((resolve) => setTimeout(resolve, 20));