@esportsplus/web-storage 0.1.28 → 0.1.30

package/build/index.d.ts

@@ -1 +1 @@
-export { default as local } from './local';
+export { default as local } from './local';

package/build/index.js

@@ -1 +1 @@
-export { default as local } from './local';
+export { default as local } from './local';

package/build/local.d.ts

@@ -1,21 +1,19 @@
-import { Filter, LocalForage, Options } from './types';
-declare class Local<T> {
-    instance: LocalForage;
-    iterate: LocalForage['iterate'];
-    keys: LocalForage['keys'];
-    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>;
-    only(...keys: (keyof T)[]): Promise<T>;
-    replace(values: T): Promise<string[]>;
-    set(key: keyof T, value: T[keyof T]): Promise<boolean>;
-}
-declare const _default: <T>(options: Options, secret?: string) => Local<T>;
-export default _default;
+import { Filter, LocalForage, Options } from './types';
+declare class Local<T> {
+    instance: LocalForage;
+    iterate: LocalForage['iterate'];
+    keys: LocalForage['keys'];
+    length: LocalForage['length'];
+    secret: null | string;
+    constructor(options: Options, secret?: string);
+    all(): Promise<T>;
+    clear(): Promise<void>;
+    delete(...keys: (keyof T)[]): Promise<void>;
+    filter(fn: Filter<T>): Promise<T>;
+    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>;
+}
+declare const _default: <T>(options: Options, secret?: string) => Local<T>;
+export default _default;

package/build/local.js

@@ -1,118 +1,119 @@
-import { Driver } from './types';
-import { decrypt, encrypt } from '@esportsplus/crypto';
-import localforage from 'localforage';
-class Local {
-    instance;
-    iterate;
-    keys;
-    length;
-    secret = null;
-    constructor(options, secret) {
-        switch ((options.driver || Driver.IndexedDB)) {
-            case Driver.LocalStorage:
-                options.driver = localforage.LOCALSTORAGE;
-                break;
-            default:
-                options.driver = localforage.INDEXEDDB;
-                break;
-        }
-        this.instance = localforage.createInstance(Object.assign(options, { storeName: options.name }));
-        this.iterate = this.instance.iterate;
-        this.keys = this.instance.keys;
-        this.length = this.instance.length;
-        if (secret) {
-            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)
-                .then((value) => {
-                if (value === undefined) {
-                    return;
-                }
-                values[k] = value;
-            })
-                .catch(() => { }));
-        });
-        await Promise.allSettled(stack);
-        return values;
-    }
-    async clear() {
-        await this.instance.clear();
-    }
-    async delete(...keys) {
-        let stack = [];
-        for (let i = 0, n = keys.length; i < n; i++) {
-            stack.push(this.instance.removeItem(keys[i]));
-        }
-        await Promise.allSettled(stack);
-    }
-    async filter(fn) {
-        let stop = () => {
-            stopped = true;
-        }, stopped = false, values = {};
-        await this.instance.iterate(async (v, k, i) => {
-            let key = k, value = await this.deserialize(v).catch(() => undefined);
-            if (value === undefined) {
-                return;
-            }
-            if (await fn({ i, key, stop, value })) {
-                values[key] = value;
-            }
-            if (stopped) {
-                return true;
-            }
-        });
-        return values;
-    }
-    async get(key) {
-        return await this.deserialize(await this.instance.getItem(key)).catch(() => undefined);
-    }
-    async only(...keys) {
-        return await this.filter(({ key }) => keys.includes(key));
-    }
-    async replace(values) {
-        let failed = [], stack = [];
-        for (let key in values) {
-            stack.push(this.set(key, values[key])
-                .then((ok) => {
-                if (ok) {
-                    return;
-                }
-                failed.push(key);
-            }));
-        }
-        await Promise.allSettled(stack);
-        return failed;
-    }
-    async set(key, value) {
-        let ok = true;
-        await this.instance.setItem(key, await this.serialize(value).catch(() => {
-            ok = false;
-            return undefined;
-        }));
-        return ok;
-    }
-}
-export default (options, secret) => new Local(options, secret);
+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;
+    keys;
+    length;
+    secret = null;
+    constructor(options, secret) {
+        switch ((options.driver || Driver.IndexedDB)) {
+            case Driver.LocalStorage:
+                options.driver = localforage.LOCALSTORAGE;
+                break;
+            default:
+                options.driver = localforage.INDEXEDDB;
+                break;
+        }
+        this.instance = localforage.createInstance(Object.assign(options, { storeName: options.name }));
+        this.iterate = this.instance.iterate;
+        this.keys = this.instance.keys;
+        this.length = this.instance.length;
+        if (secret) {
+            this.secret = secret;
+        }
+    }
+    async all() {
+        let stack = [], values = {};
+        await this.instance.iterate((v, k) => {
+            stack.push(deserialize(v, this.secret)
+                .then((value) => {
+                if (value === undefined) {
+                    return;
+                }
+                values[k] = value;
+            })
+                .catch(() => { }));
+        });
+        await Promise.allSettled(stack);
+        return values;
+    }
+    async clear() {
+        await this.instance.clear();
+    }
+    async delete(...keys) {
+        let stack = [];
+        for (let i = 0, n = keys.length; i < n; i++) {
+            stack.push(this.instance.removeItem(keys[i]));
+        }
+        await Promise.allSettled(stack);
+    }
+    async filter(fn) {
+        let stop = () => {
+            stopped = true;
+        }, stopped = false, values = {};
+        await this.instance.iterate(async (v, k, i) => {
+            let key = k, value = await deserialize(v, this.secret).catch(() => undefined);
+            if (value === undefined) {
+                return;
+            }
+            if (await fn({ i, key, stop, value })) {
+                values[key] = value;
+            }
+            if (stopped) {
+                return true;
+            }
+        });
+        return values;
+    }
+    async get(key) {
+        return await deserialize(await this.instance.getItem(key), this.secret).catch(() => undefined);
+    }
+    async only(...keys) {
+        return await this.filter(({ key }) => keys.includes(key));
+    }
+    async replace(values) {
+        let failed = [], stack = [];
+        for (let key in values) {
+            stack.push(this.set(key, values[key])
+                .then((ok) => {
+                if (ok) {
+                    return;
+                }
+                failed.push(key);
+            }));
+        }
+        await Promise.allSettled(stack);
+        return failed;
+    }
+    async set(key, value) {
+        let ok = true;
+        await this.instance.setItem(key, await serialize(value, this.secret)
+            .catch(() => {
+            ok = false;
+            return undefined;
+        }));
+        return ok;
+    }
+}
+export default (options, secret) => new Local(options, secret);

package/build/types.d.ts

@@ -1,20 +1,20 @@
-import localforage from 'localforage';
-declare enum Driver {
-    IndexedDB = 0,
-    LocalStorage = 1
-}
-type Filter<T> = (data: {
-    i: number;
-    key: keyof T;
-    stop: VoidFunction;
-    value: T[keyof T];
-}) => boolean | Promise<boolean>;
-type LocalForage = typeof localforage;
-type Options = {
-    description?: string;
-    driver?: string | string[];
-    name: string;
-    size?: number;
-    version?: number;
-};
-export { Driver, Filter, LocalForage, Options };
+import localforage from 'localforage';
+declare enum Driver {
+    IndexedDB = 0,
+    LocalStorage = 1
+}
+type Filter<T> = (data: {
+    i: number;
+    key: keyof T;
+    stop: VoidFunction;
+    value: T[keyof T];
+}) => boolean | Promise<boolean>;
+type LocalForage = typeof localforage;
+type Options = {
+    description?: string;
+    driver?: string | string[];
+    name: string;
+    size?: number;
+    version?: number;
+};
+export { Driver, Filter, LocalForage, Options };

package/build/types.js

@@ -1,7 +1,7 @@
-var Driver;
-(function (Driver) {
-    Driver[Driver["IndexedDB"] = 0] = "IndexedDB";
-    Driver[Driver["LocalStorage"] = 1] = "LocalStorage";
-})(Driver || (Driver = {}));
-;
-export { Driver };
+var Driver;
+(function (Driver) {
+    Driver[Driver["IndexedDB"] = 0] = "IndexedDB";
+    Driver[Driver["LocalStorage"] = 1] = "LocalStorage";
+})(Driver || (Driver = {}));
+;
+export { Driver };

package/package.json

@@ -6,7 +6,7 @@
     },
     "description": "Web storage utility",
     "devDependencies": {
-        "@esportsplus/webpack": "^0.0.97"
+        "@esportsplus/rspack": "^0.0.15"
     },
     "main": "build/index.js",
     "name": "@esportsplus/web-storage",
@@ -18,5 +18,5 @@
         "prepublishOnly": "npm run build"
     },
     "types": "build/index.d.ts",
-    "version": "0.1.28"
+    "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,11 +128,11 @@ 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)[]) {
-        return await this.filter(({ key }) => keys.includes(key));
+        return await this.filter( ({ key }) => keys.includes(key) );
     }
 
     async replace(values: 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;

package/tsconfig.json

@@ -5,6 +5,6 @@
         "outDir": "build"
     },
     "exclude": ["node_modules"],
-    "extends": "@esportsplus/webpack/tsconfig.base.json",
+    "extends": "@esportsplus/rspack/tsconfig.base.json",
     "include": ["src"]
 }