Don't use the same memoized function across instances when .decorator() is used

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> {
@@ -66,6 +68,15 @@ interface Options<
 	readonly cache?: CacheStorage<CacheKeyType, ReturnType<FunctionToMemoize>>;
 }
 
+interface DecoratorOptions {
+	/**
+	Whether the same memoized function should be used in different instances or a different one should be initialised for each one.
+
+	@default false
+	*/
+	readonly isAcrossInstances?: boolean;
+}
+
 /**
 [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.
 
@@ -170,7 +181,10 @@ mem.decorator = <
 	FunctionToMemoize extends AnyFunction,
 	CacheKeyType
 >(
-	options: Options<FunctionToMemoize, CacheKeyType> = {}
+	{
+		isAcrossInstances = false,
+		...options
+	}: Options<FunctionToMemoize, CacheKeyType> & DecoratorOptions = {}
 ) => (
 	target: any,
 	propertyKey: string,
@@ -182,7 +196,23 @@ mem.decorator = <
 		throw new TypeError('The decorated value must be a function');
 	}
 
-	descriptor.value = mem(input, options);
+	if (isAcrossInstances) {
+		descriptor.value = mem(input, options);
+		return;
+	}
+
+	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

@@ -204,7 +204,14 @@ Returns a TypeScript decorator which memoizes the given function.
 
 Type: `object`
 
-Same as options for `mem()`.
+Same as options for `mem()` and the following:
+
+##### isAcrossInstances
+
+Type: `boolean`\
+Default: `false`
+
+Whether the same memoized function should be used in different instances or a different one should be initialised for each one.
 
 ```ts
 import mem = require('mem');

test.ts

@@ -238,21 +238,41 @@ 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');
+
+	returnValue++;
+
+	class TestClass2 {
+		@mem.decorator({isAcrossInstances: true})
+		counter() {
+			return returnValue;
+		}
+	}
+
+	const charlie = new TestClass2();
+	t.is(charlie.counter(), 3);
+	t.is(charlie.counter(), 3, 'The method should be memoized');
+
+	returnValue++;
+
+	const delta = new TestClass2();
+	t.is(delta.counter(), 3, 'The method should be memoized across instances');
 });
 
 test('mem.clear() throws when called with a plain function', t => {