@esportsplus/web-storage 0.3.5 → 0.4.0

package/src/drivers/memory.ts

@@ -0,0 +1,92 @@
+import type { Driver } from '~/types';
+
+
+let stores = new Map<string, Map<unknown, unknown>>();
+
+
+class MemoryDriver<T> implements Driver<T> {
+
+    private store: Map<keyof T, T[keyof T]>;
+
+
+    constructor(name: string, _version: number) {
+        let existing = stores.get(name);
+
+        if (existing) {
+            this.store = existing as Map<keyof T, T[keyof T]>;
+        }
+        else {
+            this.store = new Map();
+            stores.set(name, this.store as Map<unknown, unknown>);
+        }
+    }
+
+
+    async all(): Promise<T> {
+        let result = {} as T;
+
+        for (let [key, value] of this.store) {
+            result[key] = value;
+        }
+
+        return result;
+    }
+
+    async clear(): Promise<void> {
+        this.store.clear();
+    }
+
+    async count(): Promise<number> {
+        return this.store.size;
+    }
+
+    async delete(keys: (keyof T)[]): Promise<void> {
+        for (let i = 0, n = keys.length; i < n; i++) {
+            this.store.delete(keys[i]);
+        }
+    }
+
+    async get(key: keyof T): Promise<T[keyof T] | undefined> {
+        return this.store.get(key);
+    }
+
+    async keys(): Promise<(keyof T)[]> {
+        return [...this.store.keys()];
+    }
+
+    async map(fn: (value: T[keyof T], key: keyof T, i: number) => void | Promise<void>): Promise<void> {
+        let i = 0;
+
+        for (let [key, value] of this.store) {
+            await fn(value, key, i++);
+        }
+    }
+
+    async only(keys: (keyof T)[]): Promise<Map<keyof T, T[keyof T]>> {
+        let results = new Map<keyof T, T[keyof T]>();
+
+        for (let i = 0, n = keys.length; i < n; i++) {
+            let value = this.store.get(keys[i]);
+
+            if (value !== undefined) {
+                results.set(keys[i], value);
+            }
+        }
+
+        return results;
+    }
+
+    async replace(entries: [keyof T, T[keyof T]][]): Promise<void> {
+        for (let i = 0, n = entries.length; i < n; i++) {
+            this.store.set(entries[i][0], entries[i][1]);
+        }
+    }
+
+    async set(key: keyof T, value: T[keyof T]): Promise<boolean> {
+        this.store.set(key, value);
+        return true;
+    }
+}
+
+
+export { MemoryDriver };

package/src/drivers/sessionstorage.ts

@@ -0,0 +1,131 @@
+import type { Driver } from '~/types';
+
+
+class SessionStorageDriver<T> implements Driver<T> {
+
+    private prefix: string;
+
+
+    constructor(name: string, version: number) {
+        this.prefix = `${name}:${version}:`;
+    }
+
+
+    private getKeys(): string[] {
+        let keys: string[] = [];
+
+        for (let i = 0, n = sessionStorage.length; i < n; i++) {
+            let key = sessionStorage.key(i);
+
+            if (key && key.startsWith(this.prefix)) {
+                keys.push(key.slice(this.prefix.length));
+            }
+        }
+
+        return keys;
+    }
+
+    private key(key: keyof T): string {
+        return this.prefix + String(key);
+    }
+
+    private parse(value: string | null): unknown {
+        if (value === null) {
+            return undefined;
+        }
+
+        try {
+            return JSON.parse(value);
+        }
+        catch {
+            return undefined;
+        }
+    }
+
+
+    async all(): Promise<T> {
+        let keys = this.getKeys(),
+            result = {} as T;
+
+        for (let i = 0, n = keys.length; i < n; i++) {
+            let value = this.parse(sessionStorage.getItem(this.prefix + keys[i]));
+
+            if (value !== undefined) {
+                result[keys[i] as keyof T] = value as T[keyof T];
+            }
+        }
+
+        return result;
+    }
+
+    async clear(): Promise<void> {
+        let keys = this.getKeys();
+
+        for (let i = 0, n = keys.length; i < n; i++) {
+            sessionStorage.removeItem(this.prefix + keys[i]);
+        }
+    }
+
+    async count(): Promise<number> {
+        return this.getKeys().length;
+    }
+
+    async delete(keys: (keyof T)[]): Promise<void> {
+        for (let i = 0, n = keys.length; i < n; i++) {
+            sessionStorage.removeItem(this.key(keys[i]));
+        }
+    }
+
+    async get(key: keyof T): Promise<T[keyof T] | undefined> {
+        return this.parse(sessionStorage.getItem(this.key(key))) as T[keyof T] | undefined;
+    }
+
+    async keys(): Promise<(keyof T)[]> {
+        return this.getKeys() as (keyof T)[];
+    }
+
+    async map(fn: (value: T[keyof T], key: keyof T, i: number) => void | Promise<void>): Promise<void> {
+        let keys = this.getKeys();
+
+        for (let i = 0, n = keys.length; i < n; i++) {
+            let value = this.parse(sessionStorage.getItem(this.prefix + keys[i]));
+
+            if (value !== undefined) {
+                await fn(value as T[keyof T], keys[i] as keyof T, i);
+            }
+        }
+    }
+
+    async only(keys: (keyof T)[]): Promise<Map<keyof T, T[keyof T]>> {
+        let results = new Map<keyof T, T[keyof T]>();
+
+        for (let i = 0, n = keys.length; i < n; i++) {
+            let value = this.parse(sessionStorage.getItem(this.key(keys[i])));
+
+            if (value !== undefined) {
+                results.set(keys[i], value as T[keyof T]);
+            }
+        }
+
+        return results;
+    }
+
+    async replace(entries: [keyof T, T[keyof T]][]): Promise<void> {
+        for (let i = 0, n = entries.length; i < n; i++) {
+            sessionStorage.setItem(this.key(entries[i][0]), JSON.stringify(entries[i][1]));
+        }
+    }
+
+    async set(key: keyof T, value: T[keyof T]): Promise<boolean> {
+        try {
+            sessionStorage.setItem(this.key(key), JSON.stringify(value));
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+}
+
+
+export { SessionStorageDriver };