@esportsplus/web-storage 0.1.27 → 0.1.29

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,21 @@
-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<void>;
-    set(key: keyof T, value: T[keyof T]): Promise<void>;
-}
-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);
+    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;

package/build/local.js

@@ -1,109 +1,118 @@
-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') {
-            try {
-                value = JSON.parse(value);
-            }
-            catch {
-                return undefined;
-            }
-        }
-        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;
-            }));
-        });
-        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);
-            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));
-    }
-    async only(...keys) {
-        return await this.filter(({ key }) => keys.includes(key));
-    }
-    async replace(values) {
-        let stack = [];
-        for (let key in values) {
-            stack.push(this.set(key, values[key]));
-        }
-        await Promise.allSettled(stack);
-    }
-    async set(key, value) {
-        await this.instance.setItem(key, await this.serialize(value));
-    }
-}
-export default (options, secret) => new Local(options, secret);
+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);

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

@@ -1,12 +1,12 @@
 {
     "author": "ICJR",
     "dependencies": {
-        "@esportsplus/crypto": "^0.0.2",
+        "@esportsplus/crypto": "^0.0.4",
         "localforage": "^1.10.0"
     },
     "description": "Web storage utility",
     "devDependencies": {
-        "@esportsplus/webpack": "^0.0.81"
+        "@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.27"
+    "version": "0.1.29"
 }

package/src/local.ts

@@ -40,12 +40,7 @@ class Local<T> {
         }
 
         if (typeof value === 'string') {
-            try {
-                value = JSON.parse(value);
-            }
-            catch {
-                return undefined;
-            }
+            value = JSON.parse(value);
         }
 
         return value as T[keyof T];
@@ -72,13 +67,15 @@ class Local<T> {
 
         await this.instance.iterate((v: unknown, k: string) => {
             stack.push(
-                this.deserialize(v).then((value) => {
-                    if (value === undefined) {
-                        return;
-                    }
-
-                    values[k as keyof T] = value;
-                })
+                this.deserialize(v)
+                    .then((value) => {
+                        if (value === undefined) {
+                            return;
+                        }
+
+                        values[k as keyof T] = value;
+                    })
+                    .catch(() => {})
             )
         });
 
@@ -110,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);
+                value = await this.deserialize(v).catch(() => undefined);
 
             if (value === undefined) {
                 return;
@@ -131,25 +128,47 @@ class Local<T> {
     }
 
     async get(key: keyof T) {
-        return await this.deserialize( await this.instance.getItem(key as string) );
+        return await this.deserialize( await this.instance.getItem(key as string) ).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) {
-        let stack: Promise<void>[] = [];
+        let failed: string[] = [],
+            stack: Promise<void>[] = [];
 
         for (let key in values) {
-            stack.push( this.set(key, values[key]) );
+            stack.push(
+                this.set(key, values[key])
+                    .then((ok) => {
+                        if (ok) {
+                            return;
+                        }
+
+                        failed.push(key);
+                    })
+            );
         }
 
         await Promise.allSettled(stack);
+
+        return failed;
     }
 
     async set(key: keyof T, value: T[keyof T]) {
-        await this.instance.setItem(key as string, await this.serialize(value));
+        let ok = true;
+
+        await this.instance.setItem(
+            key as string,
+            await this.serialize(value).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"]
 }