feat(memoizecapped): adding specialized memoize function version

clears the memoize function's cache when it exceeds max size

src/memoizeCapped.test.ts

@@ -0,0 +1,18 @@
+import { memoizeCapped, MAX_MEMOIZE_SIZE } from './memoizeCapped';
+
+describe('memoizeCapped', () => {
+  it('should enforce a max cache size of `MAX_MEMOIZE_SIZE`', () => {
+    function identity<T>(value: T): T {
+      return value;
+    }
+    const memoized = memoizeCapped(identity);
+    const cache = memoized.cache;
+
+    Array.from(Array(MAX_MEMOIZE_SIZE).keys()).forEach((value, index) => {
+      memoized(index);
+    });
+    expect(cache.size).toEqual(MAX_MEMOIZE_SIZE);
+    memoized(MAX_MEMOIZE_SIZE);
+    expect(cache.size).toEqual(1);
+  });
+});

src/memoizeCapped.ts

@@ -0,0 +1,24 @@
+import { memoize } from './memoize';
+import { MemoizeInterface } from './types';
+
+/** Used as the maximum memoize cache size. */
+export const MAX_MEMOIZE_SIZE = 500;
+
+/**
+ * A specialized version of `memoize` which clears the memoized function's
+ * cache when it exceeds `MAX_MEMOIZE_SIZE`.
+ * @private
+ * @param {Function} func The function to have its output memoized.
+ * @returns {Function} Returns the new memoized function.
+ */
+export function memoizeCapped(func: Function): MemoizeInterface {
+  const result = memoize(func, (key: any) => {
+    const { cache } = result;
+    if (cache.size === MAX_MEMOIZE_SIZE) {
+      cache.clear();
+    }
+    return key;
+  });
+
+  return result;
+}