rozod 2.1.1 → 3.1.0

package/lib/cache.d.ts

@@ -1,9 +1,22 @@
+type CacheEntry<T> = {
+    value: T;
+    expiresAt?: number;
+};
+interface CacheStore<T> {
+    get(key: string): Promise<CacheEntry<T> | null>;
+    set(key: string, value: CacheEntry<T>): Promise<void>;
+    delete(key: string): Promise<void>;
+    clear(): Promise<void>;
+}
 declare class Cache<T> {
-    private cache;
-    get(key: string): T | null;
-    set(key: string, value: T, ttl?: number): void;
-    delete(key: string): void;
-    clear(): void;
+    private store;
+    constructor(store: CacheStore<T>);
+    get(key: string): Promise<T | null>;
+    set(key: string, value: T, ttl?: number): Promise<void>;
+    delete(key: string): Promise<void>;
+    clear(): Promise<void>;
 }
-export declare const cache: Cache<any>;
+export declare const cache: Cache<unknown>;
+export declare const localStorageCache: Cache<unknown>;
+export declare const chromeStorageCache: Cache<unknown>;
 export {};

package/lib/cache.js

@@ -1,32 +1,95 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.cache = void 0;
+exports.chromeStorageCache = exports.localStorageCache = exports.cache = void 0;
+class MemoryStore {
+    store = {};
+    async get(key) {
+        return this.store[key] || null;
+    }
+    async set(key, value) {
+        this.store[key] = value;
+    }
+    async delete(key) {
+        delete this.store[key];
+    }
+    async clear() {
+        this.store = {};
+    }
+}
+class LocalStorageStore {
+    async get(key) {
+        const value = localStorage.getItem(key);
+        return value ? JSON.parse(value) : null;
+    }
+    async set(key, value) {
+        localStorage.setItem(key, JSON.stringify(value));
+    }
+    async delete(key) {
+        localStorage.removeItem(key);
+    }
+    async clear() {
+        localStorage.clear();
+    }
+}
+class ChromeStore {
+    async get(key) {
+        return new Promise((resolve) => {
+            // @ts-ignore
+            chrome.storage.local.get(key, (result) => {
+                resolve(result[key]);
+            });
+        });
+    }
+    async set(key, value) {
+        return new Promise((resolve) => {
+            let item = {};
+            item[key] = value;
+            // @ts-ignore
+            chrome.storage.local.set(item, resolve);
+        });
+    }
+    async delete(key) {
+        return new Promise((resolve) => {
+            // @ts-ignore
+            chrome.storage.local.remove(key, resolve);
+        });
+    }
+    async clear() {
+        return new Promise((resolve) => {
+            // @ts-ignore
+            chrome.storage.local.clear(resolve);
+        });
+    }
+}
 class Cache {
-    constructor() {
-        this.cache = {};
+    store;
+    constructor(store) {
+        this.store = store;
     }
-    get(key) {
-        const entry = this.cache[key];
+    async get(key) {
+        const entry = await this.store.get(key);
         if (!entry) {
             return null;
         }
         if (entry.expiresAt && entry.expiresAt < Date.now()) {
-            delete this.cache[key];
+            await this.delete(key);
             return null;
         }
         return entry.value;
     }
-    set(key, value, ttl) {
-        this.cache[key] = {
+    async set(key, value, ttl) {
+        await this.store.set(key, {
             value,
             expiresAt: ttl ? Date.now() + ttl : undefined,
-        };
+        });
     }
-    delete(key) {
-        delete this.cache[key];
+    async delete(key) {
+        await this.store.delete(key);
     }
-    clear() {
-        this.cache = {};
+    async clear() {
+        await this.store.clear();
     }
 }
-exports.cache = new Cache();
+exports.cache = new Cache(new MemoryStore());
+exports.localStorageCache = new Cache(new LocalStorageStore());
+exports.chromeStorageCache = new Cache(new ChromeStore());