Don't use the same memoized function across instances when `.decorato…

…r()` is used (#75)

index.ts

@@ -4,6 +4,8 @@ import mapAgeCleaner = require('map-age-cleaner');
 
 type AnyFunction = (...arguments_: any) => any;
 
+const decoratorInstanceMap = new WeakMap();
+
 const cacheStore = new WeakMap<AnyFunction>();
 
 interface CacheStorageContent<ValueType> {
@@ -141,7 +143,7 @@ const mem = <
 export = mem;
 
 /**
-@returns A TypeScript decorator which memoizes the given function.
+@returns A [decorator](https://github.com/tc39/proposal-decorators) to memoize class methods or static class methods.
 
 @example
 ```
@@ -182,7 +184,18 @@ mem.decorator = <
 		throw new TypeError('The decorated value must be a function');
 	}
 
-	descriptor.value = mem(input, options);
+	delete descriptor.value;
+	delete descriptor.writable;
+
+	descriptor.get = function () {
+		if (!decoratorInstanceMap.has(this)) {
+			const value = mem(input, options);
+			decoratorInstanceMap.set(this, value);
+			return value;
+		}
+
+		return decoratorInstanceMap.get(this);
+	};
 };
 
 /**

readme.md

@@ -198,7 +198,7 @@ Refer to the [caching strategies](#caching-strategy) section for more informatio
 
 ### mem.decorator(options)
 
-Returns a [decorator](https://github.com/tc39/proposal-decorators) to memoize class methods.
+Returns a [decorator](https://github.com/tc39/proposal-decorators) to memoize class methods or static class methods.
 
 Notes:
 

test.ts

@@ -238,21 +238,23 @@ test('prototype support', t => {
 });
 
 test('.decorator()', t => {
-	class TestClass {
-		index = 0;
+	let returnValue = 1;
 
+	class TestClass {
 		@mem.decorator()
 		counter() {
-			return ++this.index;
+			return returnValue;
 		}
 	}
 
 	const alpha = new TestClass();
 	t.is(alpha.counter(), 1);
 	t.is(alpha.counter(), 1, 'The method should be memoized');
 
+	returnValue++;
+
 	const beta = new TestClass();
-	t.is(beta.counter(), 1, 'The method should not be memoized across instances');
+	t.is(beta.counter(), 2, 'The method should not be memoized across instances');
 });
 
 test('mem.clear() throws when called with a plain function', t => {