@esportsplus/web-storage 0.1.29 → 0.1.30

package/build/local.d.ts

@@ -6,13 +6,11 @@ declare class Local<T> {
     length: LocalForage['length'];
     secret: null | string;
     constructor(options: Options, secret?: string);
-    private deserialize;
-    private serialize;
     all(): Promise<T>;
     clear(): Promise<void>;
     delete(...keys: (keyof T)[]): Promise<void>;
     filter(fn: Filter<T>): Promise<T>;
-    get(key: keyof T): Promise<T[keyof T] | undefined>;
+    get(key: keyof T): Promise<unknown>;
     only(...keys: (keyof T)[]): Promise<T>;
     replace(values: T): Promise<string[]>;
     set(key: keyof T, value: T[keyof T]): Promise<boolean>;

package/build/local.js

@@ -1,6 +1,25 @@
 import { Driver } from './types';
 import { decrypt, encrypt } from '@esportsplus/crypto';
 import localforage from 'localforage';
+async function deserialize(value, secret = null) {
+    if (secret && typeof value === 'string') {
+        value = await decrypt(value, secret);
+    }
+    if (typeof value === 'string') {
+        value = JSON.parse(value);
+    }
+    return value;
+}
+async function serialize(value, secret = null) {
+    if (value === null || value === undefined) {
+        return undefined;
+    }
+    value = JSON.stringify(value);
+    if (secret) {
+        value = await encrypt(value, secret);
+    }
+    return value;
+}
 class Local {
     instance;
     iterate;
@@ -24,29 +43,10 @@ class Local {
             this.secret = secret;
         }
     }
-    async deserialize(value) {
-        if (this.secret && typeof value === 'string') {
-            value = await decrypt(value, this.secret);
-        }
-        if (typeof value === 'string') {
-            value = JSON.parse(value);
-        }
-        return value;
-    }
-    async serialize(value) {
-        if (value === null || value === undefined) {
-            return undefined;
-        }
-        value = JSON.stringify(value);
-        if (this.secret) {
-            value = await encrypt(value, this.secret);
-        }
-        return value;
-    }
     async all() {
         let stack = [], values = {};
         await this.instance.iterate((v, k) => {
-            stack.push(this.deserialize(v)
+            stack.push(deserialize(v, this.secret)
                 .then((value) => {
                 if (value === undefined) {
                     return;
@@ -73,7 +73,7 @@ class Local {
             stopped = true;
         }, stopped = false, values = {};
         await this.instance.iterate(async (v, k, i) => {
-            let key = k, value = await this.deserialize(v).catch(() => undefined);
+            let key = k, value = await deserialize(v, this.secret).catch(() => undefined);
             if (value === undefined) {
                 return;
             }
@@ -87,7 +87,7 @@ class Local {
         return values;
     }
     async get(key) {
-        return await this.deserialize(await this.instance.getItem(key)).catch(() => undefined);
+        return await deserialize(await this.instance.getItem(key), this.secret).catch(() => undefined);
     }
     async only(...keys) {
         return await this.filter(({ key }) => keys.includes(key));
@@ -108,7 +108,8 @@ class Local {
     }
     async set(key, value) {
         let ok = true;
-        await this.instance.setItem(key, await this.serialize(value).catch(() => {
+        await this.instance.setItem(key, await serialize(value, this.secret)
+            .catch(() => {
             ok = false;
             return undefined;
         }));

package/package.json

@@ -18,5 +18,5 @@
         "prepublishOnly": "npm run build"
     },
     "types": "build/index.d.ts",
-    "version": "0.1.29"
+    "version": "0.1.30"
 }

package/src/local.ts

@@ -3,6 +3,33 @@ import { decrypt, encrypt } from '@esportsplus/crypto';
 import localforage from 'localforage';
 
 
+async function deserialize(value: unknown, secret: null | string = null) {
+    if (secret && typeof value === 'string') {
+        value = await decrypt(value, secret);
+    }
+
+    if (typeof value === 'string') {
+        value = JSON.parse(value);
+    }
+
+    return value;
+}
+
+async function serialize(value: unknown, secret: null | string = null) {
+    if (value === null || value === undefined) {
+        return undefined;
+    }
+
+    value = JSON.stringify(value);
+
+    if (secret) {
+        value = await encrypt(value as string, secret);
+    }
+
+    return value as string;
+}
+
+
 class Local<T> {
     instance: LocalForage;
     iterate: LocalForage['iterate'];
@@ -34,46 +61,19 @@ class Local<T> {
     }
 
 
-    private async deserialize(value: unknown) {
-        if (this.secret && typeof value === 'string') {
-            value = await decrypt(value, this.secret);
-        }
-
-        if (typeof value === 'string') {
-            value = JSON.parse(value);
-        }
-
-        return value as T[keyof T];
-    }
-
-    private async serialize(value: unknown) {
-        if (value === null || value === undefined) {
-            return undefined;
-        }
-
-        value = JSON.stringify(value);
-
-        if (this.secret) {
-            value = await encrypt(value as string, this.secret);
-        }
-
-        return value as string;
-    }
-
-
     async all(): Promise<T> {
         let stack: Promise<void>[] = [],
             values: T = {} as T;
 
         await this.instance.iterate((v: unknown, k: string) => {
             stack.push(
-                this.deserialize(v)
+                deserialize(v, this.secret)
                     .then((value) => {
                         if (value === undefined) {
                             return;
                         }
 
-                        values[k as keyof T] = value;
+                        values[k as keyof T] = value as T[keyof T];
                     })
                     .catch(() => {})
             )
@@ -107,7 +107,7 @@ class Local<T> {
 
         await this.instance.iterate(async (v, k, i) => {
             let key = k as keyof T,
-                value = await this.deserialize(v).catch(() => undefined);
+                value = await deserialize(v, this.secret).catch(() => undefined) as T[keyof T];
 
             if (value === undefined) {
                 return;
@@ -128,7 +128,7 @@ class Local<T> {
     }
 
     async get(key: keyof T) {
-        return await this.deserialize( await this.instance.getItem(key as string) ).catch(() => undefined);
+        return await deserialize( await this.instance.getItem(key as string), this.secret ).catch(() => undefined);
     }
 
     async only(...keys: (keyof T)[]) {
@@ -162,10 +162,11 @@ class Local<T> {
 
         await this.instance.setItem(
             key as string,
-            await this.serialize(value).catch(() => {
-                ok = false;
-                return undefined;
-            })
+            await serialize(value, this.secret)
+                .catch(() => {
+                    ok = false;
+                    return undefined;
+                })
         );
 
         return ok;