🤖 Merge PR DefinitelyTyped#72379 fix(timed-cache): add type: module, add callback option, jsdoc by @hkleungai

Author: hkleungai

attw.json

@@ -335,7 +335,6 @@
         "tasker-js-runner",
         "tern",
         "throttle-debounce",
-        "timed-cache",
         "tryghost__content-api",
         "typography",
         "uikit",

types/timed-cache/index.d.ts

@@ -1,23 +1,51 @@
 export interface CacheOptions {
-    defaultTtl: number;
+    /**
+     * Specify what default value you would like the TTL to have when creating the storage
+     * @default 60 * 1000
+     */
+    defaultTtl?: number | undefined;
 }
 
-export interface PutOptions {
-    ttl: number;
+export interface PutOptions<T = any> {
+    /**
+     * You can customize the time-to-live value of a key/value pair at insertion time
+     */
+    ttl?: number | undefined;
+
+    /**
+     * Define a callback for each inserted key/value pair to be informed when it is actually evicted from the storage
+     */
+    callback?: ((key: Key, value: T) => void) | undefined;
 }
 
 export type Key = string | object;
 
 export default class Cache<T> {
     constructor(options?: CacheOptions);
-
+    /**
+     * Clears the internal cache.
+     */
     clear(): void;
 
+    /**
+     * Returns a cached value associated with the given key if it exists,
+     * returns an undefined value otherwise.
+     */
     get(key: Key): T | undefined;
 
-    put(key: Key, value: T, options?: PutOptions): void;
+    /**
+     * Puts a key/value pair into the cache storage.
+     */
+    put(key: Key, value: T, options?: PutOptions<T>): void;
 
+    /**
+     * Clears the cache entry associated with the given `key`.
+     */
     remove(key: Key): void;
 
+    /**
+     * Returns the size of the cache object in
+     * terms of referenced elements.
+     */
     size(): number;
 }

types/timed-cache/package.json

@@ -2,6 +2,7 @@
     "private": true,
     "name": "@types/timed-cache",
     "version": "2.0.9999",
+    "type": "module",
     "projects": [
         "https://github.com/HQarroum/timed-cache#readme"
     ],

types/timed-cache/timed-cache-tests.ts

@@ -1,20 +1,55 @@
 import Cache, { CacheOptions } from "timed-cache";
 
-const option: CacheOptions = { defaultTtl: 5000 };
-const cache = new Cache<string>(option); // $ExpectType Cache<string>
-cache.put("key", "value", { ttl: 1000 }); // $ExpectType void
-cache.get("key"); // $ExpectType string | undefined
-
-interface Foo {
-    thing: string;
+// constructor
+{
+    new Cache<string>();
+    new Cache<string>({});
+    new Cache<string>({ defaultTtl: 5000 });
 }
 
-const cache2 = new Cache<Foo>();
-cache2.put("key", { thing: "foo" }); // $ExpectType void
-cache2.get("key"); // $Expect Type Foo
+// Method
+
+{
+    interface Foo {
+        thing: string;
+    }
+
+    const cache = new Cache<Foo>();
+
+    // $ExpectType void
+    cache.clear();
 
-const cache3 = new Cache<Foo>();
-const objKey = { what: "ever" };
-cache3.put(objKey, { thing: "foo" }); // $ExpectType void
-cache3.get(objKey); // $Expect Type Foo
-cache3.remove(objKey); // $Expect Type void
+    // $ExpectType Foo | undefined
+    cache.get("key");
+    // $ExpectType Foo | undefined
+    cache.get({ key: "val" });
+
+    // $ExpectType void
+    cache.put("key", { thing: "foo" }, {
+        ttl: 50,
+        callback: (key, value) => {
+            // $ExpectType Key
+            key;
+            // $ExpectType Foo
+            value;
+        },
+    });
+    // $ExpectType void
+    cache.put({ key: "val" }, { thing: "foo" }, {
+        ttl: 50,
+        callback: (key, value) => {
+            // $ExpectType Key
+            key;
+            // $ExpectType Foo
+            value;
+        },
+    });
+
+    // $Expect Type void
+    cache.remove("key");
+    // $Expect Type void
+    cache.remove({ key: "val" });
+
+    // $ExpectType number
+    cache.size();
+}