@esportsplus/web-storage 0.1.14 → 0.1.16

package/build/index.d.ts

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

package/build/index.js

@@ -1,9 +1,4 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.local = void 0;
-const local_1 = __importDefault(require("./local"));
-exports.local = local_1.default;
-exports.default = { local: local_1.default };
+import local from './local';
+import memory from './memory';
+export default { local, memory };
+export { local, memory };

package/build/local/index.d.ts

@@ -1,21 +1,20 @@
-import { Object, Options } from './types';
-declare class Store {
+import { Options } from './types';
+declare class Store<T> {
     instance: LocalForage;
     iterate: LocalForage['iterate'];
     keys: LocalForage['keys'];
     length: LocalForage['length'];
     constructor(options: Options);
-    all(): Promise<Object>;
+    all(): Promise<T | {}>;
     clear(): Promise<void>;
-    delete(...keys: string[]): Promise<void>;
-    filter(filter: Function): Promise<Object>;
-    get(...keys: string[]): Promise<any>;
-    has(...keys: string[]): Promise<boolean>;
-    set(values: {
-        [key: string]: any;
-    }): Promise<void>;
+    delete(...keys: (keyof T)[]): Promise<void>;
+    filter(filter: Function): 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: {
-    store: (options: Options) => Store;
+    store: <T>(options: Options) => Store<T>;
 };
 export default _default;

package/build/local/index.js

@@ -1,10 +1,5 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const types_1 = require("./types");
-const localforage_1 = __importDefault(require("localforage"));
+import { Driver } from './types';
+import localforage from 'localforage';
 class Store {
     instance;
     iterate;
@@ -12,15 +7,15 @@ class Store {
     length;
     constructor(options) {
         let driver;
-        switch ((options.driver || types_1.Driver.IndexedDB)) {
-            case types_1.Driver.LocalStorage:
-                driver = localforage_1.default.LOCALSTORAGE;
+        switch ((options.driver || Driver.IndexedDB)) {
+            case Driver.LocalStorage:
+                driver = localforage.LOCALSTORAGE;
                 break;
             default:
-                driver = localforage_1.default.INDEXEDDB;
+                driver = localforage.INDEXEDDB;
                 break;
         }
-        this.instance = localforage_1.default.createInstance(Object.assign(options, { driver, storeName: options.name }));
+        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;
@@ -57,31 +52,25 @@ class Store {
         });
         return values;
     }
-    async get(...keys) {
-        if (keys.length === 1) {
-            return await this.instance.getItem(keys[0]);
+    async get(key) {
+        let value = await this.instance.getItem(key);
+        if (value === null) {
+            return undefined;
         }
-        return await this.filter((key) => keys.includes(key));
+        return value;
     }
-    async has(...keys) {
-        let haystack = await this.instance.keys();
-        for (let i = 0, n = keys.length; i < n; i++) {
-            if (haystack.includes(keys[i])) {
-                continue;
-            }
-            return false;
-        }
-        return true;
+    async only(...keys) {
+        return await this.filter((key) => keys.includes(key));
     }
-    async set(values) {
-        if (!Object.keys(values).length) {
-            return;
-        }
+    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);
+    }
 }
-exports.default = {
+export default {
     store: (options) => new Store(options)
 };

package/build/local/types.d.ts

@@ -2,10 +2,7 @@ declare enum Driver {
     IndexedDB = 0,
     LocalStorage = 1
 }
-declare type Object = {
-    [key: string]: any;
-};
 declare type Options = LocalForageOptions & {
     name: string;
 };
-export { Driver, Object, Options };
+export { Driver, Options };

package/build/local/types.js

@@ -1,10 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Driver = void 0;
 var Driver;
 (function (Driver) {
     Driver[Driver["IndexedDB"] = 0] = "IndexedDB";
     Driver[Driver["LocalStorage"] = 1] = "LocalStorage";
 })(Driver || (Driver = {}));
-exports.Driver = Driver;
 ;
+export { Driver };

package/build/memory/index.d.ts

@@ -0,0 +1,16 @@
+declare class Store<T> {
+    store: T;
+    constructor(data: T | {});
+    all(): {} & T;
+    clear(): void;
+    delete(key: keyof T): void;
+    filter(filter: Function): Promise<T | {}>;
+    get(key: keyof T): T[keyof T];
+    only(...keys: (keyof T)[]): any;
+    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

@@ -0,0 +1,51 @@
+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/package.json

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

package/src/index.ts

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

package/src/local/index.ts

@@ -1,8 +1,8 @@
-import { Driver, Object, Options } from './types';
+import { Driver, Options } from './types';
 import localforage from 'localforage';
 
 
-class Store {
+class Store<T> {
     instance: LocalForage;
     iterate: LocalForage['iterate'];
     keys: LocalForage['keys'];
@@ -30,40 +30,40 @@ class Store {
     }
 
 
-    async all(): Promise<Object> {
-        let values: Object = {};
+    async all(): Promise<T | {}> {
+        let values: T = {} as T;
 
         await this.instance.iterate((value: any, key: string) => {
-            values[key] = value;
+            values[key as keyof T] = value;
         });
 
         return values;
     }
 
-    async clear(): Promise<void> {
+    async clear() {
         await this.instance.clear();
     }
 
-    async delete(...keys: string[]): Promise<void> {
+    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]);
+            await this.instance.removeItem(keys[i] as string);
         }
     }
 
-    async filter(filter: Function): Promise<Object> {
+    async filter(filter: Function): Promise<T | {}> {
         let s: () => void = () => {
                 stop = true;
             },
             stop: boolean = false,
-            values: Object = {};
+            values: T = {} as T;
 
         await this.instance.iterate((value: any, key: string, i: number) => {
             if (filter({ i, key, stop: s, value })) {
-                values[key] = value;
+                values[key as keyof T] = value;
             }
 
             // LocalForage iterate will stop once a non
@@ -76,40 +76,32 @@ class Store {
         return values;
     }
 
-    async get(...keys: string[]): Promise<any> {
-        if (keys.length === 1) {
-            return await this.instance.getItem(keys[0]);
-        }
-
-        return await this.filter((key: string) => keys.includes(key));
-    }
-
-    async has(...keys: string[]): Promise<boolean> {
-        let haystack = await this.instance.keys();
-
-        for (let i = 0, n = keys.length; i < n; i++) {
-            if (haystack.includes(keys[i])) {
-                continue;
-            }
+    async get(key: keyof T) {
+        let value: T[keyof T] | null = await this.instance.getItem(key as string);
 
-            return false;
+        if (value === null) {
+            return undefined;
         }
 
-        return true;
+        return value;
     }
 
-    async set(values: { [key: string]: any }): Promise<void> {
-        if (!Object.keys(values).length) {
-            return;
-        }
+    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: (options: Options): Store => new Store(options)
+    store: <T>(options: Options) => new Store<T>(options)
 };

package/src/local/types.ts

@@ -3,9 +3,7 @@ enum Driver {
     LocalStorage
 };
 
-type Object = { [key: string]: any };
-
 type Options = LocalForageOptions & { name: string };
 
 
-export { Driver, Object, Options };
+export { Driver, Options };

package/src/memory/index.ts

@@ -0,0 +1,72 @@
+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 | {}> {
+        let s: () => void = () => {
+                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: any = {};
+
+        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)
+};

package/tsconfig.json

@@ -1,12 +1,13 @@
 {
     "compilerOptions": {
         "allowJs": true,
+        "allowSyntheticDefaultImports": true,
         "alwaysStrict": true,
         "baseUrl": "src",
         "declaration": true,
         "declarationDir": "./build",
-        "lib": ["dom", "ESNext"],
-        "module": "NodeNext",
+        "lib": ["dom", "esnext"],
+        "module": "esnext",
         "moduleResolution": "node",
         "noUnusedLocals": true,
         "noUnusedParameters": true,
@@ -17,7 +18,7 @@
         "removeComments": true,
         "resolveJsonModule": true,
         "strict": true,
-        "target": "ESNext"
+        "target": "esnext"
     },
     "exclude": ["node_modules"],
     "include": ["src"],