@esportsplus/web-storage 0.1.25 → 0.1.26

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,18 @@
+import { LocalForage, Options } from './types';
+declare class Local<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: <T>(options: Options) => Local<T>;
+export default _default;

package/build/local.js

@@ -0,0 +1,74 @@
+import { Driver } from './types';
+import localforage from 'localforage';
+class Local {
+    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 (options) => new Local(options);

package/build/types.d.ts

@@ -0,0 +1,14 @@
+import localforage from 'localforage';
+declare enum Driver {
+    IndexedDB = 0,
+    LocalStorage = 1
+}
+type LocalForage = typeof localforage;
+type Options = {
+    description?: string;
+    driver?: string | string[];
+    name: string;
+    size?: number;
+    version?: number;
+};
+export { Driver, LocalForage, Options };

package/build/types.js

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

package/package.json

@@ -5,7 +5,7 @@
     },
     "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 +17,5 @@
         "prepublishOnly": "npm run build"
     },
     "types": "build/index.d.ts",
-    "version": "0.1.25"
+    "version": "0.1.26"
 }

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/index.ts → local.ts}

@@ -2,7 +2,7 @@ import { Driver, LocalForage, Options } from './types';
 import localforage from 'localforage';
 
 
-class Store<T> {
+class Local<T> {
     instance: LocalForage;
     iterate: LocalForage['iterate'];
     keys: LocalForage['keys'];
@@ -102,6 +102,4 @@ class Store<T> {
 }
 
 
-export default {
-    store: <T>(options: Options) => new Store<T>(options)
-};
+export default <T>(options: Options) => new Local<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)
-};