@esportsplus/web-storage 0.1.7 → 0.1.8

package/build/index.d.ts

@@ -6,24 +6,22 @@ declare const _default: {
             iterate: <T, U>(iteratee: (value: T, 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>;
-            promises: (Promise<any> | (() => void))[];
-            assign(key: string, value: import("./local/types").Object): void;
+            assign(key: string, value: import("./local/types").Object): Promise<void>;
             clear(): Promise<void>;
-            delete(...keys: string[]): void;
+            delete(...keys: string[]): Promise<void>;
             entries(): Promise<import("./local/types").Object>;
             filter(fn: Function): Promise<import("./local/types").Object>;
             get(key: string, value?: any): Promise<any>;
             has(...keys: string[]): Promise<boolean>;
             only(...keys: string[]): Promise<import("./local/types").Object>;
             pop(key: string): Promise<any>;
-            push(key: string, ...values: any[]): void;
+            push(key: string, ...values: any[]): Promise<void>;
             replace(values: {
                 [key: string]: any;
-            }): void;
+            }): Promise<void>;
             shift(key: string): Promise<any>;
-            set(key: string, value: any): void;
-            sync(): Promise<void>;
-            unshift(key: string, ...values: any[]): void;
+            set(key: string, value: any): Promise<void>;
+            unshift(key: string, ...values: any[]): Promise<void>;
         };
     };
 };

package/build/local/index.d.ts

@@ -4,25 +4,23 @@ declare class Store {
     iterate: LocalForage['iterate'];
     keys: LocalForage['keys'];
     length: LocalForage['length'];
-    promises: (Promise<any> | (() => void))[];
     constructor(options?: LocalForageOptions);
-    assign(key: string, value: Object): void;
+    assign(key: string, value: Object): Promise<void>;
     clear(): Promise<void>;
-    delete(...keys: string[]): void;
+    delete(...keys: string[]): Promise<void>;
     entries(): Promise<Object>;
     filter(fn: Function): Promise<Object>;
     get(key: string, value?: any): Promise<any>;
     has(...keys: string[]): Promise<boolean>;
     only(...keys: string[]): Promise<Object>;
     pop(key: string): Promise<any>;
-    push(key: string, ...values: any[]): void;
+    push(key: string, ...values: any[]): Promise<void>;
     replace(values: {
         [key: string]: any;
-    }): void;
+    }): Promise<void>;
     shift(key: string): Promise<any>;
-    set(key: string, value: any): void;
-    sync(): Promise<void>;
-    unshift(key: string, ...values: any[]): void;
+    set(key: string, value: any): Promise<void>;
+    unshift(key: string, ...values: any[]): Promise<void>;
 }
 declare const _default: {
     store: (options?: LocalForageOptions) => Store;

package/build/local/index.js

@@ -10,7 +10,6 @@ class Store {
     iterate;
     keys;
     length;
-    promises;
     constructor(options = {}) {
         let driver, name = options.name || 'store';
         switch ((options.driver || types_1.Driver.IndexedDB)) {
@@ -25,32 +24,25 @@ class Store {
         this.iterate = this.instance.iterate;
         this.keys = this.instance.keys;
         this.length = this.instance.length;
-        this.promises = [];
     }
-    assign(key, value) {
-        let transaction = async () => {
-            let data = (await this.get(key)) || {};
-            await this.instance.setItem(key, Object.assign(data, value));
-        };
-        this.promises.push(transaction());
+    async assign(key, value) {
+        let data = (await this.get(key)) || {};
+        await this.instance.setItem(key, Object.assign(data, value));
     }
-    clear() {
-        this.promises = [];
-        return this.instance.clear();
+    async clear() {
+        await this.instance.clear();
     }
-    delete(...keys) {
+    async delete(...keys) {
         if (!keys.length) {
             return;
         }
         for (let i = 0, n = keys.length; i < n; i++) {
-            this.promises.push(this.instance.removeItem(keys[i]));
+            await this.instance.removeItem(keys[i]);
         }
     }
     async entries() {
         let values = {};
-        await this.instance.iterate((value, key) => {
-            values[key] = value;
-        });
+        await this.instance.iterate((value, key) => (values[key] = value));
         return values;
     }
     async filter(fn) {
@@ -100,50 +92,41 @@ class Store {
     async pop(key) {
         let value, values = (await this.get(key)) || [];
         value = values.pop();
-        this.promises.push(this.instance.setItem(key, values));
+        await this.instance.setItem(key, values);
         return value;
     }
-    push(key, ...values) {
+    async push(key, ...values) {
         if (!values.length) {
             return;
         }
-        let transaction = async () => {
-            let data = (await this.get(key)) || [];
-            data.push(...values);
-            await this.instance.setItem(key, data);
-        };
-        this.promises.push(transaction());
+        let data = (await this.get(key)) || [];
+        data.push(...values);
+        await this.instance.setItem(key, data);
     }
-    replace(values) {
+    async replace(values) {
         if (!Object.keys(values).length) {
             return;
         }
         for (let key in values) {
-            this.promises.push(this.instance.setItem(key, values[key]));
+            await this.instance.setItem(key, values[key]);
         }
     }
     async shift(key) {
         let value, values = (await this.get(key)) || [];
         value = values.shift();
-        this.promises.push(this.instance.setItem(key, values));
+        await this.instance.setItem(key, values);
         return value;
     }
-    set(key, value) {
-        this.promises.push(this.instance.setItem(key, value));
-    }
-    async sync() {
-        await Promise.allSettled(this.promises.splice(0));
+    async set(key, value) {
+        await this.instance.setItem(key, value);
     }
-    unshift(key, ...values) {
+    async unshift(key, ...values) {
         if (!values.length) {
             return;
         }
-        let transaction = async () => {
-            let data = (await this.get(key)) || [];
-            data.unshift(...values);
-            await this.instance.setItem(key, data);
-        };
-        this.promises.push(transaction());
+        let data = (await this.get(key)) || [];
+        data.unshift(...values);
+        await this.instance.setItem(key, data);
     }
 }
 exports.default = {

package/package.json

@@ -23,5 +23,5 @@
         "prepublishOnly": "npm run build"
     },
     "types": "./build/index.d.ts",
-    "version": "0.1.7"
+    "version": "0.1.8"
 }

package/src/local/index.ts

@@ -7,7 +7,6 @@ class Store {
     iterate: LocalForage['iterate'];
     keys: LocalForage['keys'];
     length: LocalForage['length'];
-    promises: (Promise<any> | (() => void))[];
 
 
     constructor(options: LocalForageOptions = {}) {
@@ -23,49 +22,42 @@ class Store {
                 break;
         }
 
-        this.instance = localforage.createInstance( Object.assign(options, { driver, name, storeName: name }) );
+        this.instance = localforage.createInstance( 
+            Object.assign(options, { driver, name, storeName: name }) 
+        );
         this.iterate = this.instance.iterate;
         this.keys = this.instance.keys;
         this.length = this.instance.length;
-        this.promises = [];
     }
 
 
-    assign(key: string, value: Object): void {
-        let transaction = async () => {
-                let data = (await this.get(key)) || {};
-
-                await this.instance.setItem(
-                    key, 
-                    Object.assign(data, value)
-                );
-            };
-
-        this.promises.push( transaction() );
+    async assign(key: string, value: Object): Promise<void> {
+        let data = (await this.get(key)) || {};
+            
+        await this.instance.setItem(
+            key, 
+            Object.assign(data, value)
+        );
     }
 
-    clear(): Promise<void> {
-        this.promises = [];
-
-        return this.instance.clear();
+    async clear(): Promise<void> {
+        await this.instance.clear();
     }
 
-    delete(...keys: string[]): void {
+    async delete(...keys: string[]): Promise<void> {
         if (!keys.length) {
             return;
         }
 
         for (let i = 0, n = keys.length; i < n; i++) {
-            this.promises.push(this.instance.removeItem(keys[i]));
+            await this.instance.removeItem(keys[i]);
         }
     }
 
     async entries(): Promise<Object> {
         let values: Object = {};
 
-        await this.instance.iterate((value: any, key: string) => {
-            values[key] = value;
-        });
+        await this.instance.iterate((value: any, key: string) => (values[key] = value));
 
         return values;
     }
@@ -136,34 +128,30 @@ class Store {
 
         value = values.pop();
 
-        this.promises.push( this.instance.setItem(key, values) );
+        await this.instance.setItem(key, values);
 
         return value;
     }
 
-    push(key: string, ...values: any[]): void {
+    async push(key: string, ...values: any[]): Promise<void> {
         if (!values.length) {
             return;
         }
 
-        let transaction = async () => {
-                let data = (await this.get(key)) || [];
+        let data = (await this.get(key)) || []; 
 
-                data.push(...values);
+        data.push(...values);
 
-                await this.instance.setItem(key, data);
-            };
-
-        this.promises.push( transaction() );
+        await this.instance.setItem(key, data);
     }
 
-    replace(values: { [key: string]: any }): void {
+   async replace(values: { [key: string]: any }): Promise<void> {
         if (!Object.keys(values).length) {
             return;
         }
 
         for (let key in values) {
-            this.promises.push( this.instance.setItem(key, values[key]) );
+            await this.instance.setItem(key, values[key]);
         }
     }
 
@@ -173,33 +161,25 @@ class Store {
 
         value = values.shift();
 
-        this.promises.push( this.instance.setItem(key, values) );
+        await this.instance.setItem(key, values);
 
         return value;
     }
 
-    set(key: string, value: any): void {
-        this.promises.push( this.instance.setItem(key, value) );
-    }
-
-    async sync(): Promise<void> { 
-        await Promise.allSettled(this.promises.splice(0));
+    async set(key: string, value: any): Promise<void> {
+        await this.instance.setItem(key, value);
     }
 
-    unshift(key: string, ...values: any[]): void {
+    async unshift(key: string, ...values: any[]): Promise<void> {
         if (!values.length) {
             return;
         }
 
-        let transaction = async () => {
-                let data = (await this.get(key)) || [];
-
-                data.unshift(...values);
+        let data = (await this.get(key)) || [];
 
-                await this.instance.setItem(key, data);
-            };
+        data.unshift(...values);
 
-        this.promises.push( transaction() );
+        await this.instance.setItem(key, data);
     }
 }