@esportsplus/web-storage 0.1.25 → 0.1.27

package/build/index.d.ts

@@ -1,35 +1 @@
-import local from './local';
-import memory from './memory';
-declare const _default: {
-    local: {
-        store: <T>(options: import("./local/types").Options) => {
-            instance: LocalForage;
-            iterate: <T_1, U>(iteratee: (value: T_1, key: string, iterationNumber: number) => U, callback?: ((err: any, result: U) => void) | undefined) => Promise<U>;
-            keys: (callback?: ((err: any, keys: string[]) => void) | undefined) => Promise<string[]>;
-            length: (callback?: ((err: any, numberOfKeys: number) => void) | undefined) => Promise<number>;
-            all(): Promise<Record<string, never> | T>;
-            clear(): Promise<void>;
-            delete(...keys: (keyof T)[]): Promise<void>;
-            filter(filter: Function): Promise<Record<string, never> | T>;
-            get(key: keyof T): Promise<(T[keyof T] & {}) | undefined>;
-            only(...keys: (keyof T)[]): Promise<Record<string, never> | T>;
-            replace(values: T): Promise<void>;
-            set(key: keyof T, value: T[keyof T]): Promise<void>;
-        };
-    };
-    memory: {
-        store: <T_2>(data: T_2) => {
-            store: T_2;
-            all(): {} & T_2;
-            clear(): void;
-            delete(key: keyof T_2): void;
-            filter(filter: Function): Promise<Record<string, never> | T_2>;
-            get(key: keyof T_2): T_2[keyof T_2];
-            only(...keys: (keyof T_2)[]): T_2;
-            replace(values: T_2): void;
-            set(key: keyof T_2, value: T_2[keyof T_2]): void;
-        };
-    };
-};
-export default _default;
-export { local, memory };
+export { default as local } from './local';

package/build/index.js

@@ -1,4 +1 @@
-import local from './local';
-import memory from './memory';
-export default { local, memory };
-export { local, memory };
+export { default as local } from './local';

package/build/local.d.ts

@@ -0,0 +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;

package/build/local.js

@@ -0,0 +1,109 @@
+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);

package/build/{local/types.d.ts → types.d.ts}

@@ -3,6 +3,12 @@ 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;
@@ -11,4 +17,4 @@ type Options = {
     size?: number;
     version?: number;
 };
-export { Driver, LocalForage, Options };
+export { Driver, Filter, LocalForage, Options };

package/package.json

@@ -1,11 +1,12 @@
 {
     "author": "ICJR",
     "dependencies": {
+        "@esportsplus/crypto": "^0.0.2",
         "localforage": "^1.10.0"
     },
     "description": "Web storage utility",
     "devDependencies": {
-        "@esportsplus/webpack": "^0.0.80"
+        "@esportsplus/webpack": "^0.0.81"
     },
     "main": "build/index.js",
     "name": "@esportsplus/web-storage",
@@ -17,5 +18,5 @@
         "prepublishOnly": "npm run build"
     },
     "types": "build/index.d.ts",
-    "version": "0.1.25"
+    "version": "0.1.27"
 }

package/src/index.ts

@@ -1,6 +1 @@
-import local from './local';
-import memory from './memory';
-
-
-export default { local, memory };
-export { local, memory };
+export { default as local } from './local';

package/src/local.ts

@@ -0,0 +1,157 @@
+import { Driver, Filter, LocalForage, Options } from '~/types';
+import { decrypt, encrypt } from '@esportsplus/crypto';
+import localforage from 'localforage';
+
+
+class Local<T> {
+    instance: LocalForage;
+    iterate: LocalForage['iterate'];
+    keys: LocalForage['keys'];
+    length: LocalForage['length'];
+    secret: null | string = null;
+
+
+    constructor(options: Options, secret?: string) {
+        switch ((options.driver || Driver.IndexedDB) as Driver) {
+            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;
+        }
+    }
+
+
+    private async deserialize(value: unknown) {
+        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 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).then((value) => {
+                    if (value === undefined) {
+                        return;
+                    }
+
+                    values[k as keyof T] = value;
+                })
+            )
+        });
+
+        await Promise.allSettled(stack);
+
+        return values;
+    }
+
+    async clear() {
+        await this.instance.clear();
+    }
+
+    async delete(...keys: (keyof T)[]) {
+        let stack: Promise<void>[] = [];
+
+        for (let i = 0, n = keys.length; i < n; i++) {
+            stack.push( this.instance.removeItem(keys[i] as string) );
+        }
+
+        await Promise.allSettled(stack);
+    }
+
+    async filter(fn: Filter<T>): Promise<T> {
+        let stop: VoidFunction = () => {
+                stopped = true;
+            },
+            stopped: boolean = false,
+            values: T = {} as T;
+
+        await this.instance.iterate(async (v, k, i) => {
+            let key = k as keyof T,
+                value = await this.deserialize(v);
+
+            if (value === undefined) {
+                return;
+            }
+
+            if (await fn({ i, key, stop, value })) {
+                values[key] = value;
+            }
+
+            // LocalForage iterate will stop once a non
+            // undefined value is returned
+            if (stopped) {
+                return true;
+            }
+        });
+
+        return values;
+    }
+
+    async get(key: keyof T) {
+        return await this.deserialize( await this.instance.getItem(key as string) );
+    }
+
+    async only(...keys: (keyof T)[]) {
+        return await this.filter(({ key }) => keys.includes(key));
+    }
+
+    async replace(values: T) {
+        let stack: Promise<void>[] = [];
+
+        for (let key in values) {
+            stack.push( this.set(key, values[key]) );
+        }
+
+        await Promise.allSettled(stack);
+    }
+
+    async set(key: keyof T, value: T[keyof T]) {
+        await this.instance.setItem(key as string, await this.serialize(value));
+    }
+}
+
+
+export default <T>(options: Options, secret?: string) => new Local<T>(options, secret);

package/src/{local/types.ts → types.ts}

@@ -6,6 +6,8 @@ enum Driver {
     LocalStorage
 };
 
+type Filter<T> = (data: { i: number, key: keyof T, stop: VoidFunction, value: T[keyof T] }) => boolean | Promise<boolean>;
+
 type LocalForage = typeof localforage;
 
 type Options = {
@@ -17,4 +19,4 @@ type Options = {
 };
 
 
-export { Driver, LocalForage, Options };
+export { Driver, Filter, LocalForage, Options };

package/build/local/index.d.ts

@@ -1,20 +0,0 @@
-import { LocalForage, Options } from './types';
-declare class Store<T> {
-    instance: LocalForage;
-    iterate: LocalForage['iterate'];
-    keys: LocalForage['keys'];
-    length: LocalForage['length'];
-    constructor(options: Options);
-    all(): Promise<T | Record<string, never>>;
-    clear(): Promise<void>;
-    delete(...keys: (keyof T)[]): Promise<void>;
-    filter(filter: Function): Promise<T | Record<string, never>>;
-    get(key: keyof T): Promise<(T[keyof T] & {}) | undefined>;
-    only(...keys: (keyof T)[]): Promise<T | Record<string, never>>;
-    replace(values: T): Promise<void>;
-    set(key: keyof T, value: T[keyof T]): Promise<void>;
-}
-declare const _default: {
-    store: <T>(options: Options) => Store<T>;
-};
-export default _default;

package/build/local/index.js

@@ -1,76 +0,0 @@
-import { Driver } from './types';
-import localforage from 'localforage';
-class Store {
-    instance;
-    iterate;
-    keys;
-    length;
-    constructor(options) {
-        let driver;
-        switch ((options.driver || Driver.IndexedDB)) {
-            case Driver.LocalStorage:
-                driver = localforage.LOCALSTORAGE;
-                break;
-            default:
-                driver = localforage.INDEXEDDB;
-                break;
-        }
-        this.instance = localforage.createInstance(Object.assign(options, { driver, storeName: options.name }));
-        this.iterate = this.instance.iterate;
-        this.keys = this.instance.keys;
-        this.length = this.instance.length;
-    }
-    async all() {
-        let values = {};
-        await this.instance.iterate((value, key) => {
-            values[key] = value;
-        });
-        return values;
-    }
-    async clear() {
-        await this.instance.clear();
-    }
-    async delete(...keys) {
-        if (!keys.length) {
-            return;
-        }
-        for (let i = 0, n = keys.length; i < n; i++) {
-            await this.instance.removeItem(keys[i]);
-        }
-    }
-    async filter(filter) {
-        let s = () => {
-            stop = true;
-        }, stop = false, values = {};
-        await this.instance.iterate((value, key, i) => {
-            if (filter({ i, key, stop: s, value })) {
-                values[key] = value;
-            }
-            if (stop) {
-                return true;
-            }
-        });
-        return values;
-    }
-    async get(key) {
-        let value = await this.instance.getItem(key);
-        if (value === null) {
-            return undefined;
-        }
-        return value;
-    }
-    async only(...keys) {
-        return await this.filter((key) => keys.includes(key));
-    }
-    async replace(values) {
-        for (let key in values) {
-            await this.instance.setItem(key, values[key]);
-        }
-    }
-    async set(key, value) {
-        await this.instance.setItem(key, value);
-    }
-}
-export default {
-    store: (options) => new Store(options)
-};

package/build/memory/index.d.ts

@@ -1,16 +0,0 @@
-declare class Store<T> {
-    store: T;
-    constructor(data: T);
-    all(): {} & T;
-    clear(): void;
-    delete(key: keyof T): void;
-    filter(filter: Function): Promise<T | Record<string, never>>;
-    get(key: keyof T): T[keyof T];
-    only(...keys: (keyof T)[]): T;
-    replace(values: T): void;
-    set(key: keyof T, value: T[keyof T]): void;
-}
-declare const _default: {
-    store: <T>(data: T) => Store<T>;
-};
-export default _default;

package/build/memory/index.js

@@ -1,51 +0,0 @@
-class Store {
-    store;
-    constructor(data) {
-        this.store = data;
-    }
-    all() {
-        return Object.assign({}, this.store);
-    }
-    clear() {
-        this.store = {};
-    }
-    delete(key) {
-        delete this.store[key];
-    }
-    async filter(filter) {
-        let s = () => {
-            stop = true;
-        }, stop = false, values = {};
-        for (let key in this.store) {
-            let value = this.store[key];
-            if (await filter({ key, stop: s, value })) {
-                values[key] = value;
-            }
-            if (stop) {
-                break;
-            }
-        }
-        return values;
-    }
-    get(key) {
-        return this.store[key];
-    }
-    only(...keys) {
-        let data = {};
-        for (let i = 0, n = keys.length; i < n; i++) {
-            data[keys[i]] = this.store[keys[i]];
-        }
-        return data;
-    }
-    replace(values) {
-        for (let key in values) {
-            this.store[key] = values[key];
-        }
-    }
-    set(key, value) {
-        this.store[key] = value;
-    }
-}
-export default {
-    store: (data) => new Store(data)
-};

package/src/local/index.ts

@@ -1,107 +0,0 @@
-import { Driver, LocalForage, Options } from './types';
-import localforage from 'localforage';
-
-
-class Store<T> {
-    instance: LocalForage;
-    iterate: LocalForage['iterate'];
-    keys: LocalForage['keys'];
-    length: LocalForage['length'];
-
-
-    constructor(options: Options) {
-        let driver;
-
-        switch ((options.driver || Driver.IndexedDB) as Driver) {
-            case Driver.LocalStorage:
-                driver = localforage.LOCALSTORAGE;
-                break;
-            default:
-                driver = localforage.INDEXEDDB;
-                break;
-        }
-
-        this.instance = localforage.createInstance(
-            Object.assign(options, { driver, storeName: options.name })
-        );
-        this.iterate = this.instance.iterate;
-        this.keys = this.instance.keys;
-        this.length = this.instance.length;
-    }
-
-
-    async all(): Promise<T | Record<string, never>> {
-        let values: T = {} as T;
-
-        await this.instance.iterate((value: any, key: string) => {
-            values[key as keyof T] = value;
-        });
-
-        return values;
-    }
-
-    async clear() {
-        await this.instance.clear();
-    }
-
-    async delete(...keys: (keyof T)[]) {
-        if (!keys.length) {
-            return;
-        }
-
-        for (let i = 0, n = keys.length; i < n; i++) {
-            await this.instance.removeItem(keys[i] as string);
-        }
-    }
-
-    async filter(filter: Function): Promise<T | Record<string, never>> {
-        let s: VoidFunction = () => {
-                stop = true;
-            },
-            stop: boolean = false,
-            values: T = {} as T;
-
-        await this.instance.iterate((value: any, key: string, i: number) => {
-            if (filter({ i, key, stop: s, value })) {
-                values[key as keyof T] = value;
-            }
-
-            // LocalForage iterate will stop once a non
-            // undefined value is returned
-            if (stop) {
-                return true;
-            }
-        });
-
-        return values;
-    }
-
-    async get(key: keyof T) {
-        let value: T[keyof T] | null = await this.instance.getItem(key as string);
-
-        if (value === null) {
-            return undefined;
-        }
-
-        return value;
-    }
-
-    async only(...keys: (keyof T)[]) {
-        return await this.filter((key: string) => keys.includes(key as keyof T));
-    }
-
-    async replace(values: T) {
-        for (let key in values) {
-            await this.instance.setItem(key, values[key]);
-        }
-    }
-
-    async set(key: keyof T, value: T[keyof T]) {
-        await this.instance.setItem(key as string, value);
-    }
-}
-
-
-export default {
-    store: <T>(options: Options) => new Store<T>(options)
-};

package/src/memory/index.ts

@@ -1,72 +0,0 @@
-class Store<T> {
-    store: T;
-
-
-    constructor(data: T) {
-        this.store = data as T;
-    }
-
-
-    all() {
-        return Object.assign({}, this.store);
-    }
-
-    clear() {
-        this.store = {} as T;
-    }
-
-    delete(key: keyof T) {
-        delete this.store[key];
-    }
-
-    async filter(filter: Function): Promise<T | Record<string, never>> {
-        let s: VoidFunction = () => {
-                stop = true;
-            },
-            stop: boolean = false,
-            values: T = {} as T;
-
-        for (let key in this.store) {
-            let value = this.store[key];
-
-            if (await filter({ key, stop: s, value })) {
-                values[key as keyof T] = value;
-            }
-
-            if (stop) {
-                break;
-            }
-        }
-
-        return values;
-    }
-
-    get(key: keyof T) {
-        return this.store[key];
-    }
-
-    only(...keys: (keyof T)[]) {
-        let data: T = {} as T;
-
-        for (let i = 0, n = keys.length; i < n; i++) {
-            data[keys[i]] = this.store[keys[i]];
-        }
-
-        return data;
-    }
-
-    replace(values: T) {
-        for (let key in values) {
-            this.store[key as keyof T] = values[key];
-        }
-    }
-
-    set(key: keyof T, value: T[keyof T]) {
-        this.store[key] = value;
-    }
-}
-
-
-export default {
-    store: <T>(data: T) => new Store<T>(data)
-};