avoid need for sorted array by keeping map insertion order consistent with access order

Author: EskiMojo14

library/src/methods/cache/cache.test.ts

@@ -1,4 +1,3 @@
-import { setTimeout } from 'node:timers/promises';
 import QuickLRU from 'quick-lru';
 import { afterAll, beforeEach, describe, expect, test, vi } from 'vitest';
 import { string } from '../../schemas/index.ts';
@@ -14,25 +13,21 @@ describe('cache', () => {
     );
     expect(runSpy).toHaveBeenCalledTimes(1);
   });
-  test('should allow custom max size', async () => {
+  test('should allow custom max size', () => {
     const schema = cache(string(), { maxSize: 2 });
     expect(schema.options.maxSize).toBe(2);
 
     const fooDataset = schema['~run']({ value: 'foo' }, {});
     expect(schema['~run']({ value: 'foo' }, {})).toBe(fooDataset);
 
-    // wait for next tick, to prevent same millisecond
-    await setTimeout(0);
     expect(schema['~run']({ value: 'bar' }, {})).toBe(
       schema['~run']({ value: 'bar' }, {})
     );
 
-    await setTimeout(0);
     expect(schema['~run']({ value: 'baz' }, {})).toBe(
       schema['~run']({ value: 'baz' }, {})
     );
 
-    await setTimeout(0);
     expect(schema['~run']({ value: 'foo' }, {})).not.toBe(fooDataset);
   });
   describe('should allow custom duration', () => {
@@ -45,6 +40,7 @@ describe('cache', () => {
 
     test('and clear expired values', () => {
       const schema = cache(string(), { duration: 1000 });
+
       const fooDataset = schema['~run']({ value: 'foo' }, {});
       expect(schema['~run']({ value: 'foo' }, {})).toBe(fooDataset);
       vi.advanceTimersByTime(1001);

library/src/methods/cache/cacheAsync.test.ts

@@ -1,4 +1,3 @@
-import { setTimeout } from 'node:timers/promises';
 import QuickLRU from 'quick-lru';
 import { afterAll, beforeEach, describe, expect, test, vi } from 'vitest';
 import { string } from '../../schemas/index.ts';
@@ -21,18 +20,14 @@ describe('cacheAsync', () => {
     const fooDataset = await schema['~run']({ value: 'foo' }, {});
     expect(await schema['~run']({ value: 'foo' }, {})).toBe(fooDataset);
 
-    // wait for next tick, to prevent same millisecond
-    await setTimeout(0);
     expect(await schema['~run']({ value: 'bar' }, {})).toBe(
       await schema['~run']({ value: 'bar' }, {})
     );
 
-    await setTimeout(0);
     expect(await schema['~run']({ value: 'baz' }, {})).toBe(
       await schema['~run']({ value: 'baz' }, {})
     );
 
-    await setTimeout(0);
     expect(await schema['~run']({ value: 'foo' }, {})).not.toBe(fooDataset);
   });
   describe('should allow custom duration', () => {

library/src/utils/_Cache/_Cache.test.ts

@@ -1,27 +1,24 @@
-import { setTimeout } from 'node:timers/promises';
 import { afterAll, beforeEach, describe, expect, test, vi } from 'vitest';
 import { _Cache } from './_Cache.ts';
 
 describe('_Cache', () => {
-  test('should cache values', async () => {
+  test('should cache values', () => {
     const cache = new _Cache<string, number>();
 
     cache.set('foo', 123);
     expect(cache.get('foo')).toBe(123);
 
-    // wait for next tick, to prevent same millisecond
-    await setTimeout(0);
     cache.set('bar', 456);
 
     expect(cache.get('bar')).toBe(456);
     // default max size is 1
     expect(cache.get('foo')).toBeUndefined();
   });
-  test('should allow deleting', async () => {
+  test('should allow deleting', () => {
     const cache = new _Cache<string, number>();
+
     cache.set('foo', 123);
 
-    await setTimeout(0);
     cache.set('bar', 456);
 
     cache.delete('foo');
@@ -53,15 +50,13 @@ describe('_Cache', () => {
 
     expect(cache.size).toBe(2);
   });
-  test('should allow custom max size', async () => {
+  test('should allow custom max size', () => {
     const cache = new _Cache<string, number>({ maxSize: 2 });
 
     cache.set('foo', 123);
 
-    await setTimeout(0);
     cache.set('bar', 456);
 
-    await setTimeout(0);
     cache.set('baz', 789);
 
     expect(cache.get('foo')).toBeUndefined();

library/src/utils/_Cache/_Cache.ts

@@ -30,10 +30,7 @@ export class _Cache<TKey, TValue> implements BaseCache<TKey, TValue> {
     return this['~get'](key)?.value;
   }
   set(key: TKey, value: TValue): this {
-    this['~cache'].set(key, {
-      value,
-      lastAccess: Date.now(),
-    });
+    this['~insert'](key, value);
     this['~clearExcess']();
     return this;
   }
@@ -61,16 +58,24 @@ export class _Cache<TKey, TValue> implements BaseCache<TKey, TValue> {
       this['~cache'].delete(key);
       return;
     }
-    entry.lastAccess = Date.now();
+    // move to end
+    this['~insert'](key, entry.value);
     return entry;
   }
+  private '~insert'(key: TKey, value: TValue): void {
+    // make sure this is always an insertion, not an update
+    // important for map ordering
+    this['~cache'].delete(key);
+    this['~cache'].set(key, {
+      value,
+      lastAccess: Date.now(),
+    });
+  }
   private '~clearExcess'(): void {
     if (this.size <= this.maxSize) return;
-    const entries = Array.from(this['~cache']).sort(
-      ([, a], [, b]) => b.lastAccess - a.lastAccess
-    );
+    const keys = this['~cache'].keys();
     while (this.size > this.maxSize) {
-      this['~cache'].delete(entries.pop()![0]);
+      this['~cache'].delete(keys.next().value!);
     }
   }
 }