✨ Add SlidingTaskMap

Author: Tomas2D

README.md

@@ -8,7 +8,7 @@ multiple requests to do time-consuming operations simultaneously.
 With this approach, one request will take care of creating the final data and other processes
 will asynchronously wait for the completion. 
 
-**NOTE:** This library is useful if you need a lihtweight solution without an extra service like Redis / PubSub etc.
+**NOTE:** This library is useful if you need a lightweight solution without an extra service like Redis / PubSub etc.
 
 Does this library help you? Please give it a ⭐️!
 
@@ -17,6 +17,7 @@ Does this library help you? Please give it a ⭐️!
 - Later resolving of a task in a `Promise` way
 - Auto rejecting promises removed from the shared data structure (`TaskMap`, which is an extension of a `Map` data structure)
 - Zero dependencies
+- Map with limited space (sliding-window)
 
 ## 🚀 Installation
 
@@ -108,3 +109,29 @@ app.get('/observations/:date', async function (req, res) {
   downloadDataFromS3(date).pipe(res)
 })
 ```
+
+**Sliding window**
+
+When your map size reaches a specified threshold, the oldest values will be
+removed. You can be then sure that the size of the map will never overflow your memory.
+
+```typescript
+import { Task, SlidingTaskMap } from 'promise-based-task'
+
+const WINDOW_SIZE = 10
+const tasks = new SlidingTaskMap<string, number[]>(WINDOW_SIZE)
+
+app.get('/calculation/:date', async function () {
+  const date = req.params.date
+
+  if (!tasks.has(date)) {
+    const task = new Task<void>()
+    tasks.set(date, task)
+    
+    const data = await fetchData(date)
+    task.resolve(data)
+  }
+  
+  return tasks.get(date)
+})
+```

src/SlidingTaskMap.ts

@@ -0,0 +1,41 @@
+import { Deletable } from './types';
+import TaskMap from './TaskMap';
+
+class SlidingTaskMap<K, V extends Deletable> extends TaskMap<K, V> {
+  private keysByTime: K[] = [];
+
+  constructor(private readonly windowSize: number) {
+    super();
+    if (windowSize < 1 || isNaN(Number(windowSize))) {
+      throw new TypeError(`windowSize cannot be less than 1!`);
+    }
+  }
+
+  set(key: K, value: V): this {
+    if (this.has(key)) {
+      return super.set(key, value);
+    }
+
+    if (this.size + 1 > this.windowSize) {
+      this.delete(this.keysByTime[0]);
+    }
+    this.keysByTime.push(key);
+    return super.set(key, value);
+  }
+
+  delete(key: K): boolean {
+    const didDelete = super.delete(key);
+    if (didDelete) {
+      const deleteIndex = this.keysByTime.indexOf(key);
+      this.keysByTime.splice(deleteIndex, 1);
+    }
+    return didDelete;
+  }
+
+  clear() {
+    super.clear();
+    this.keysByTime.length = 0;
+  }
+}
+
+export default SlidingTaskMap;

src/index.ts

@@ -1,4 +1,5 @@
 export { default as Task } from './Task';
 export { default as TaskMap } from './TaskMap';
+export { default as SlidingTaskMap } from './SlidingTaskMap';
 export * from './types';
 export * from './error';

test/SlidingTaskMap.test.ts

@@ -0,0 +1,53 @@
+import { Task, SlidingTaskMap } from '../src';
+
+describe('SlidingTaskMap', () => {
+  it('Counts', async () => {
+    const map = new SlidingTaskMap<string, Task<number>>(5);
+
+    expect(map.size).toBe(0);
+    map.set('1', new Task<number>(1));
+    expect(map.size).toBe(1);
+    map.delete('1');
+    expect(map.size).toBe(0);
+    map.set('2', new Task<number>(2));
+    expect(map.size).toBe(1);
+    map.set('2', new Task<number>(2));
+    expect(map.size).toBe(1);
+    map.clear();
+    expect(map.size).toBe(0);
+  });
+
+  it('Slides', async () => {
+    const WINDOW_SIZE = 5;
+    const map = new SlidingTaskMap<string, Task<string>>(WINDOW_SIZE);
+
+    const keys = Array.from({ length: 50 }).map((_, i) => String(i + 1));
+    for (const key of keys) {
+      const prevSize = Number(map.size);
+
+      const task = new Task<string>(key);
+      map.set(key, task);
+
+      expect(map.has(key)).toBe(true);
+      expect(map.get(key)).toEqual(task);
+      expect(prevSize).toBeLessThanOrEqual(map.size);
+      expect(map.size).toBeLessThanOrEqual(WINDOW_SIZE);
+    }
+
+    const resolvedValues = await Promise.all(Array.from(map.values()));
+    expect(resolvedValues).toEqual(keys.slice(-WINDOW_SIZE));
+  });
+
+  it('Throws with invalid window size', async () => {
+    expect(() => new SlidingTaskMap(0)).toThrow();
+
+    // @ts-expect-error simulating no type safety env
+    expect(() => new SlidingTaskMap()).toThrow();
+
+    // @ts-expect-error simulating no type safety env
+    expect(() => new SlidingTaskMap([])).toThrow();
+
+    // @ts-expect-error simulating no type safety env
+    expect(() => new SlidingTaskMap('x')).toThrow();
+  });
+});